#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "cpu/bop.h"
#include "int32.h"
#include "bios.h"

Include dependency graph for kbdbios.c:

Macros
#define	NDEBUG

#define	BOP_KBD_IRQ 0x09

#define	BOP_KBD_INT 0x16

Functions
VOID WINAPI	BiosKeyboardIrq (LPWORD Stack)

static VOID WINAPI	KbdBiosIRQ (LPWORD Stack)

VOID WINAPI	BiosKeyboardService (LPWORD Stack)

static VOID WINAPI	KbdBiosINT (LPWORD Stack)

BOOLEAN	KbdBiosInitialize (VOID)

VOID	KbdBiosCleanup (VOID)

Macro Definition Documentation

◆ BOP_KBD_INT

#define BOP_KBD_INT 0x16

Definition at line 27 of file kbdbios.c.

◆ BOP_KBD_IRQ

#define BOP_KBD_IRQ 0x09

Definition at line 26 of file kbdbios.c.

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file kbdbios.c.

Function Documentation

◆ BiosKeyboardIrq()

VOID WINAPI BiosKeyboardIrq ( LPWORD Stack )

Definition at line 199 of file kbdbios32.c.

{
    static BOOLEAN Extended = FALSE;
    BOOLEAN SkipScanCode;
    BYTE ScanCode, VirtualKey;
    WORD Character;
 
    /*
     * Get the scan code from the PS/2 port, then call the
     * INT 15h, AH=4Fh Keyboard Intercept function to try to
     * translate the scan code. CF must be set before the call.
     * In return, if CF is set we continue processing the scan code
     * stored in AL, and if not, we skip it.
     */
    WORD AX = getAX();
    WORD CX = getCX();
    WORD DX = getDX();
    WORD BX = getBX();
    WORD BP = getBP();
    WORD SI = getSI();
    WORD DI = getDI();
    WORD DS = getDS();
    WORD ES = getES();
 
    setCF(1);
    setAL(IOReadB(PS2_DATA_PORT));
    setAH(0x4F);
    Int32Call(&BiosContext, BIOS_MISC_INTERRUPT);
 
    /* Retrieve the modified scan code in AL */
    SkipScanCode = (getCF() == 0);
    ScanCode = getAL();
 
    setAX(AX);
    setCX(CX);
    setDX(DX);
    setBX(BX);
    setBP(BP);
    setSI(SI);
    setDI(DI);
    setDS(DS);
    setES(ES);
    setCF(0);
 
    if (ScanCode == 0xE0)
    {
        Extended = TRUE;
        Bda->KeybdStatusFlags |= 0x02;
        goto Quit;
    }
 
    // FIXME: For diagnostic purposes. We should decide what to do then!!
    if (ScanCode == 0xE1)
        DPRINT1("BiosKeyboardIrq, ScanCode == 0xE1\n");
 
    /* Check whether CF is clear. If so, skip the scan code. */
    if (SkipScanCode) goto Quit;
 
    /* Get the corresponding virtual key code */
    VirtualKey = MapVirtualKey(ScanCode & 0x7F, MAPVK_VSC_TO_VK);
 
    /* Check if this is a key press or release */
    if (!(ScanCode & (1 << 7)))
    {
        /* Key press, set the highest bit */
        BiosKeyboardMap[VirtualKey] |= (1 << 7);
 
        switch (VirtualKey)
        {
            case VK_NUMLOCK:
            case VK_CAPITAL:
            case VK_SCROLL:
            case VK_INSERT:
            {
                /* For toggle keys, toggle the lowest bit in the keyboard map */
                BiosKeyboardMap[VirtualKey] ^= ~(1 << 0);
                break;
            }
 
            case VK_SHIFT:
            case VK_LSHIFT:
            case VK_RSHIFT:
            case VK_CONTROL:
            case VK_RCONTROL:
            case VK_LCONTROL:
            case VK_MENU:
            case VK_LMENU:
            case VK_RMENU:
            {
                /* Modifier keys don't go in the buffer */
                break;
            }
 
            default:
            {
                Character = Extended ? 0xE0 : 0x00;
 
                /* If this is not an extended scancode, and ALT isn't held down, find out which character this is */
                if (!Extended && !(Bda->KeybdShiftFlags & (BDA_KBDFLAG_ALT | BDA_KBDFLAG_LALT | BDA_KBDFLAG_RALT)))
                {
                    if (ToAscii(VirtualKey, ScanCode, BiosKeyboardMap, &Character, 0) == 0)
                    {
                        /* Not ASCII */
                        Character = 0;
                    }
                }
 
                /* Push it onto the BIOS keyboard queue */
                BiosKbdBufferPush(MAKEWORD(Character, ScanCode));
            }
        }
    }
    else
    {
        /* Key release, unset the highest bit */
        BiosKeyboardMap[VirtualKey] &= ~(1 << 7);
    }
 
    /* Clear the keyboard flags */
    Bda->KeybdShiftFlags = 0;
    // Release right CTRL and ALT keys
    Bda->KeybdStatusFlags &= ~(BDA_KBDFLAG_RCTRL | BDA_KBDFLAG_RALT);
 
    /* Set the appropriate flags based on the state */
    // SHIFT
    if (BiosKeyboardMap[VK_RSHIFT]   & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_RSHIFT;
    if (BiosKeyboardMap[VK_LSHIFT]   & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LSHIFT;
    if (BiosKeyboardMap[VK_SHIFT]    & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LSHIFT;
    // CTRL
    if (BiosKeyboardMap[VK_RCONTROL] & (1 << 7)) Bda->KeybdStatusFlags |= BDA_KBDFLAG_RCTRL;
    if (BiosKeyboardMap[VK_LCONTROL] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LCTRL;
    if (BiosKeyboardMap[VK_CONTROL]  & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CTRL;
    // ALT
    if (BiosKeyboardMap[VK_RMENU]    & (1 << 7)) Bda->KeybdStatusFlags |= BDA_KBDFLAG_RALT;
    if (BiosKeyboardMap[VK_LMENU]    & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LALT;
    if (BiosKeyboardMap[VK_MENU]     & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_ALT;
    // Others
    if (BiosKeyboardMap[VK_SCROLL]   & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SCROLL_ON;
    if (BiosKeyboardMap[VK_NUMLOCK]  & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_NUMLOCK_ON;
    if (BiosKeyboardMap[VK_CAPITAL]  & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CAPSLOCK_ON;
    if (BiosKeyboardMap[VK_INSERT]   & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_INSERT_ON;
    if (BiosKeyboardMap[VK_SNAPSHOT] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SYSRQ;
    if (BiosKeyboardMap[VK_PAUSE]    & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_PAUSE;
    if (BiosKeyboardMap[VK_SCROLL]   & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SCROLL;
    if (BiosKeyboardMap[VK_NUMLOCK]  & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_NUMLOCK;
    if (BiosKeyboardMap[VK_CAPITAL]  & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CAPSLOCK;
    if (BiosKeyboardMap[VK_INSERT]   & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_INSERT;
 
    /* Clear the extended key flag */
    Extended = FALSE;
    Bda->KeybdStatusFlags &= ~0x02; // Remove the 0xE0 code flag
    // Bda->KeybdStatusFlags &= ~0x01; // Remove the 0xE1 code flag
 
    DPRINT("BiosKeyboardIrq - Character = 0x%X, ScanCode = 0x%X, KeybdShiftFlags = 0x%X\n",
           Character, ScanCode, Bda->KeybdShiftFlags);
 
Quit:
    PicIRQComplete(LOBYTE(Stack[STACK_INT_NUM]));
}

Referenced by KbdBios32Post(), and KbdBiosIRQ().

◆ BiosKeyboardService()

VOID WINAPI BiosKeyboardService ( LPWORD Stack )

Definition at line 85 of file kbdbios32.c.

{
    switch (getAH())
    {
        /* Wait for keystroke and read */
        case 0x00:
        /* Wait for extended keystroke and read */
        case 0x10:
        {
            WORD Character;
 
            /* Read the character (and wait if necessary) */
            if (!BiosKbdBufferTop(&Character))
            {
                /* No key available. Set the handler CF to repeat the BOP */
                setCF(1);
                break;
            }
 
            if (getAH() == 0x00 && LOBYTE(Character) == 0xE0)
            {
                /* Clear the extended code */
                Character &= 0xFF00;
            }
 
            BiosKbdBufferPop();
            setAX(Character);
            setCF(0);
 
            break;
        }
 
        /* Get keystroke status */
        case 0x01:
        /* Get extended keystroke status */
        case 0x11:
        {
            WORD Character;
 
            if (BiosKbdBufferTop(&Character))
            {
                /* There is a character, clear ZF and return it */
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_ZF;
 
                if (getAH() == 0x01 && LOBYTE(Character) == 0xE0)
                {
                    /* Clear the extended code */
                    Character &= 0xFF00;
                }
 
                setAX(Character);
            }
            else
            {
                /* No character, set ZF */
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_ZF;
            }
 
            break;
        }
 
        /* Get shift status */
        case 0x02:
        {
            /* Return the lower byte of the keyboard shift status word */
            setAL(LOBYTE(Bda->KeybdShiftFlags));
            break;
        }
 
        /* Reserved */
        case 0x04:
        {
            DPRINT1("BIOS Function INT 16h, AH = 0x04 is RESERVED\n");
            break;
        }
 
        /* Push keystroke */
        case 0x05:
        {
            /* Return 0 if success, 1 if failure */
            setAL(BiosKbdBufferPush(getCX()) == FALSE);
            break;
        }
 
        /* Get extended shift status */
        case 0x12:
        {
            /*
             * Be careful! The returned word is similar to 'Bda->KeybdShiftFlags'
             * but the high byte is organized differently:
             * the bits 2 and 3 of the high byte are not the same:
             * instead they correspond to the right CTRL and ALT keys as specified
             * in bits 2 and 3 of LOBYTE(Bda->KeybdStatusFlags).
             */
            // Bda->KeybdShiftFlags & 0xF3FF;
            WORD KeybdShiftFlags = MAKEWORD(LOBYTE(Bda->KeybdShiftFlags),
                                               (HIBYTE(Bda->KeybdShiftFlags ) & 0xF3) |
                                               (LOBYTE(Bda->KeybdStatusFlags) & 0x0C));
 
            /* Return the extended keyboard shift status word */
            setAX(KeybdShiftFlags);
            break;
        }
 
        default:
        {
            DPRINT1("BIOS Function INT 16h, AH = 0x%02X NOT IMPLEMENTED\n",
                    getAH());
        }
    }
}

Referenced by KbdBios32Post(), and KbdBiosINT().

◆ KbdBiosCleanup()

VOID KbdBiosCleanup ( VOID )

Definition at line 93 of file kbdbios.c.

{
    /* Unregister the BIOS support BOPs */
    RegisterBop(BOP_KBD_IRQ, NULL);
    RegisterBop(BOP_KBD_INT, NULL);
}

Referenced by Bios32Cleanup().

◆ KbdBiosInitialize()

BOOLEAN KbdBiosInitialize ( VOID )

Definition at line 85 of file kbdbios.c.

{
    /* Register the BIOS support BOPs */
    RegisterBop(BOP_KBD_IRQ, KbdBiosIRQ);   // BiosKeyboardIrq in kbdbios32.c
    RegisterBop(BOP_KBD_INT, KbdBiosINT);   // BiosKeyboardService in kbdbios32.c
    return TRUE;
}

Referenced by Bios32Initialize().

◆ KbdBiosINT()

static VOID WINAPI KbdBiosINT ( LPWORD Stack )

static

Definition at line 59 of file kbdbios.c.

{
    /*
     * Set up a false stack to hardwire the BOP function (that can directly
     * manipulate CPU registers) to the 32-bit interrupt function (which uses
     * the stack to be able to modify the original CS:IP and FLAGS).
     *
     * See int32.h stack codes.
     */
    WORD EmuStack[4];
    DWORD Flags = getEFLAGS();
 
    DPRINT1("Calling BOP KbdBiosINT\n");
 
    EmuStack[STACK_FLAGS]   = LOWORD(Flags);
    EmuStack[STACK_CS]      = getCS();
    EmuStack[STACK_IP]      = getIP();
    EmuStack[STACK_INT_NUM] = BOP_KBD_IRQ;
 
    BiosKeyboardService(EmuStack);
 
    setIP(EmuStack[STACK_IP]);
    setCS(EmuStack[STACK_CS]);
    setEFLAGS(MAKELONG(EmuStack[STACK_FLAGS], HIWORD(Flags)));
}

Referenced by KbdBiosInitialize().

◆ KbdBiosIRQ()

static VOID WINAPI KbdBiosIRQ ( LPWORD Stack )