ps2.c File Reference

#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "ps2.h"
#include "memory.h"
#include "io.h"
#include "pic.h"
#include "clock.h"

Include dependency graph for ps2.c:

Go to the source code of this file.

Classes
struct	_PS2_PORT

Macros
#define	NDEBUG
#define	BUFFER_SIZE   32
#define	PS2_PORTS   2
#define	ControllerConfig   Memory[0]

Typedefs
typedef struct _PS2_PORT	PS2_PORT
typedef struct _PS2_PORT *	PPS2_PORT

Functions
static VOID	PS2SendCommand (BYTE PS2Port, BYTE Command)
static BYTE WINAPI	PS2ReadControl (USHORT Port)
static BYTE WINAPI	PS2ReadData (USHORT Port)
static VOID WINAPI	PS2WriteControl (USHORT Port, BYTE Data)
static VOID WINAPI	PS2WriteData (USHORT Port, BYTE Data)
static VOID FASTCALL	GeneratePS2Irq (ULONGLONG ElapsedTime)
BOOLEAN	PS2PortQueueRead (BYTE PS2Port)
VOID	PS2SetDeviceCmdProc (BYTE PS2Port, LPVOID Param, PS2_DEVICE_CMDPROC DeviceCommand)
BOOLEAN	PS2QueuePush (BYTE PS2Port, BYTE Data)
BOOLEAN	PS2Initialize (VOID)
VOID	PS2Cleanup (VOID)

Variables
static PS2_PORT	Ports [PS2_PORTS]
static BYTE	Memory [0x20]
static BYTE	StatusRegister = 0x00
static BYTE	OutputBuffer = 0x00
static BYTE	ControllerCommand = 0x00
static PHARDWARE_TIMER	IrqTimer = NULL

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   32

Definition at line 31 of file ps2.c.

ControllerConfig

#define ControllerConfig   Memory[0]

Definition at line 55 of file ps2.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file ps2.c.

PS2_PORTS

#define PS2_PORTS   2

Definition at line 51 of file ps2.c.

Typedef Documentation

PPS2_PORT

typedef struct _PS2_PORT * PPS2_PORT

PS2_PORT

typedef struct _PS2_PORT PS2_PORT

Function Documentation

GeneratePS2Irq()

static VOID FASTCALL GeneratePS2Irq ( ULONGLONG  ElapsedTime )

static

Definition at line 392 of file ps2.c.

{
    UNREFERENCED_PARAMETER(ElapsedTime);
 
    /*
     * Pop out fresh new data from the PS/2 port output queues, and only
     * in case there is data ready, generate an IRQ1 or IRQ12 depending
     * on whether interrupts are enabled for the given port.
     *
     * NOTE: The first PS/2 port (keyboard) has priority over the second one (mouse).
     */
    if (PS2PortQueueRead(0))
    {
        if (ControllerConfig & PS2_CONFIG_KBD_INT) PicInterruptRequest(1);
    }
    else if (PS2PortQueueRead(1))
    {
        if (ControllerConfig & PS2_CONFIG_AUX_INT) PicInterruptRequest(12);
    }
}

Referenced by PS2Initialize().

PS2Cleanup()

VOID PS2Cleanup

(

VOID

)

Definition at line 546 of file ps2.c.

{
    DestroyHardwareTimer(IrqTimer);
 
    CloseHandle(Ports[1].QueueMutex);
    CloseHandle(Ports[0].QueueMutex);
}

Referenced by EmulatorCleanup().

PS2Initialize()

BOOLEAN PS2Initialize

(

VOID

)

Definition at line 520 of file ps2.c.

{
    /* Initialize the PS/2 ports */
    Ports[0].IsEnabled  = FALSE;
    Ports[0].QueueEmpty = TRUE;
    Ports[0].QueueStart = 0;
    Ports[0].QueueEnd   = 0;
    Ports[0].QueueMutex = CreateMutex(NULL, FALSE, NULL);
 
    Ports[1].IsEnabled  = FALSE;
    Ports[1].QueueEmpty = TRUE;
    Ports[1].QueueStart = 0;
    Ports[1].QueueEnd   = 0;
    Ports[1].QueueMutex = CreateMutex(NULL, FALSE, NULL);
 
    /* Register the I/O Ports */
    RegisterIoPort(PS2_CONTROL_PORT, PS2ReadControl, PS2WriteControl);
    RegisterIoPort(PS2_DATA_PORT   , PS2ReadData   , PS2WriteData   );
 
    IrqTimer = CreateHardwareTimer(HARDWARE_TIMER_ONESHOT,
                                   HZ_TO_NS(100),
                                   GeneratePS2Irq);
 
    return TRUE;
}

Referenced by EmulatorInitialize().

PS2PortQueueRead()

BOOLEAN PS2PortQueueRead

(

BYTE

PS2Port

)

Definition at line 415 of file ps2.c.

{
    BOOLEAN Result = FALSE;
    PPS2_PORT Port;
 
    // NOTE: The first PS/2 port (keyboard) has priority over the second one (mouse).
 
    Port = &Ports[PS2Port];
 
    if (!Port->IsEnabled) return FALSE;
 
    /* Make sure the queue is not empty (fast check) */
    if (Port->QueueEmpty)
    {
        /* Only the keyboard should have its last data latched */
        // FIXME: Alternatively this can be done in PS2ReadData when
        // we read PS2_DATA_PORT. What is the best solution??
        if (PS2Port == 0)
        {
            OutputBuffer = Port->Queue[(Port->QueueStart - 1) % BUFFER_SIZE];
            StatusRegister &= ~PS2_STAT_AUX_OUT_BUF_FULL; // Clear flag: keyboard data
        }
 
        return FALSE;
    }
 
    WaitForSingleObject(Port->QueueMutex, INFINITE);
 
    /*
     * Recheck whether the queue is not empty (it may
     * have changed after having grabbed the mutex).
     */
    if (Port->QueueEmpty) goto Done;
 
    /* Get the data */
    OutputBuffer = Port->Queue[Port->QueueStart];
 
    // StatusRegister &= ~(PS2_STAT_AUX_OUT_BUF_FULL | PS2_STAT_OUT_BUF_FULL);
 
    /* Always set the "Output buffer full" flag */
    StatusRegister |= PS2_STAT_OUT_BUF_FULL;
 
    /* Set the "Auxiliary output buffer full" flag according to where the data came from */
    if (PS2Port == 0)
        StatusRegister &= ~PS2_STAT_AUX_OUT_BUF_FULL; // Clear flag: keyboard data
    else // if (PS2Port == 1)
        StatusRegister |=  PS2_STAT_AUX_OUT_BUF_FULL; //   Set flag: mouse data
 
    /* Remove the value from the queue */
    Port->QueueStart++;
    Port->QueueStart %= BUFFER_SIZE;
 
    /* Check if the queue is now empty */
    if (Port->QueueStart == Port->QueueEnd)
        Port->QueueEmpty = TRUE;
 
    Result = TRUE;
 
Done:
    ReleaseMutex(Port->QueueMutex);
    return Result;
}

Referenced by DisableMouseInt(), DosMouseIrq(), EnableMouseInt(), GeneratePS2Irq(), ReadMouseData(), and SendMouseCommand().

PS2QueuePush()

BOOLEAN PS2QueuePush	(	BYTE	PS2Port,
		BYTE	Data
	)

Definition at line 486 of file ps2.c.

{
    BOOLEAN Result = FALSE;
    PPS2_PORT Port;
 
    ASSERT(PS2Port < PS2_PORTS);
    Port = &Ports[PS2Port];
 
    if (!Port->IsEnabled) return FALSE;
 
    WaitForSingleObject(Port->QueueMutex, INFINITE);
 
    /* Check if the queue is full */
    if (!Port->QueueEmpty && (Port->QueueStart == Port->QueueEnd))
        goto Done;
 
    /* Insert the value in the queue */
    Port->Queue[Port->QueueEnd] = Data;
    Port->QueueEnd++;
    Port->QueueEnd %= BUFFER_SIZE;
 
    /* The queue is not empty anymore */
    Port->QueueEmpty = FALSE;
 
    /* Schedule the IRQ */
    EnableHardwareTimer(IrqTimer);
 
    Result = TRUE;
 
Done:
    ReleaseMutex(Port->QueueMutex);
    return Result;
}

Referenced by KeyboardCommand(), KeyboardEventHandler(), MouseCommand(), MouseDispatchPacket(), and PS2WriteData().

PS2ReadControl()

static BYTE WINAPI PS2ReadControl ( USHORT  Port )

static

Definition at line 90 of file ps2.c.

{
    UNREFERENCED_PARAMETER(Port);
 
    /*
     * Be sure the "Keyboard enable" flag is always set.
     * On IBM PC-ATs this is the state of the hardware keyboard
     * lock mechanism. It is not widely used, but some programs
     * still use it, see for example:
     * http://www.os2museum.com/wp/the-dos-4-0-shell-mouse-mystery/
     */
    StatusRegister |= PS2_STAT_KBD_ENABLE;
 
    /* We do not have any timeouts nor parity errors */
    StatusRegister &= ~(PS2_STAT_PARITY_ERROR | PS2_STAT_GEN_TIMEOUT);
 
    return StatusRegister;
}

Referenced by PS2Initialize().

PS2ReadData()

static BYTE WINAPI PS2ReadData ( USHORT  Port )

static

Definition at line 109 of file ps2.c.

{
    UNREFERENCED_PARAMETER(Port);
 
    /*
     * If there is something to read (response byte from the
     * controller or data from a PS/2 device), read it.
     */
    StatusRegister &= ~PS2_STAT_OUT_BUF_FULL;
 
    // Keep the state of the "Auxiliary output buffer full" flag
    // in order to remember from where the data came from.
    // StatusRegister &= ~PS2_STAT_AUX_OUT_BUF_FULL;
 
    // FIXME: We may check there whether there is data latched in
    // PS2 ports 1 or 2 (keyboard or mouse) and retrieve it there...
 
    /* Always return the available byte stored in the output buffer */
    return OutputBuffer;
}

Referenced by PS2Initialize().

PS2SendCommand()

static VOID PS2SendCommand ( BYTE  PS2Port, BYTE  Command  )

static

Definition at line 67 of file ps2.c.

{
    PPS2_PORT Port;
 
    ASSERT(PS2Port < PS2_PORTS);
    Port = &Ports[PS2Port];
 
    /*
     * According to http://www.win.tue.nl/~aeb/linux/kbd/scancodes-11.html#kccad
     * any PS/2 command sent reenables the corresponding port.
     */
    if (PS2Port == 0)
        ControllerConfig &= ~PS2_CONFIG_KBD_DISABLE;
    else // if (PS2Port == 1)
        ControllerConfig &= ~PS2_CONFIG_AUX_DISABLE;
 
    Port->IsEnabled = TRUE;
 
    /* Call the device command */
    if (Port->DeviceCommand) Port->DeviceCommand(Port->Param, Command);
}

Referenced by PS2WriteData().

PS2SetDeviceCmdProc()

VOID PS2SetDeviceCmdProc	(	BYTE	PS2Port,
		LPVOID	Param,
		PS2_DEVICE_CMDPROC	DeviceCommand
	)

Definition at line 478 of file ps2.c.

{
    ASSERT(PS2Port < PS2_PORTS);
    Ports[PS2Port].Param         = Param;
    Ports[PS2Port].DeviceCommand = DeviceCommand;
}

Referenced by KeyboardInit(), and MouseInit().

PS2WriteControl()

static VOID WINAPI PS2WriteControl ( USHORT  Port, BYTE  Data  )

static

Definition at line 130 of file ps2.c.

{
    UNREFERENCED_PARAMETER(Port);
 
    switch (Data)
    {
        /* Read configuration byte (byte 0 from internal memory) */
        case 0x20:
        /* Read byte N from internal memory */
                   case 0x21: case 0x22: case 0x23:
        case 0x24: case 0x25: case 0x26: case 0x27:
        case 0x28: case 0x29: case 0x2A: case 0x2B:
        case 0x2C: case 0x2D: case 0x2E: case 0x2F:
        case 0x30: case 0x31: case 0x32: case 0x33:
        case 0x34: case 0x35: case 0x36: case 0x37:
        case 0x38: case 0x39: case 0x3A: case 0x3B:
        case 0x3C: case 0x3D: case 0x3E: case 0x3F:
        {
            OutputBuffer = Memory[Data & 0x1F];
            StatusRegister |= PS2_STAT_OUT_BUF_FULL;
            break;
        }
 
        /* Write configuration byte (byte 0 from internal memory) */
        case 0x60:
        /* Write to byte N of internal memory */
                   case 0x61: case 0x62: case 0x63:
        case 0x64: case 0x65: case 0x66: case 0x67:
        case 0x68: case 0x69: case 0x6A: case 0x6B:
        case 0x6C: case 0x6D: case 0x6E: case 0x6F:
        case 0x70: case 0x71: case 0x72: case 0x73:
        case 0x74: case 0x75: case 0x76: case 0x77:
        case 0x78: case 0x79: case 0x7A: case 0x7B:
        case 0x7C: case 0x7D: case 0x7E: case 0x7F:
 
        /* Write controller output port */
        case 0xD1:
        /* Write to the first PS/2 port output buffer */
        case 0xD2:
        /* Write to the second PS/2 port output buffer */
        case 0xD3:
        /* Write to the second PS/2 port input buffer */
        case 0xD4:
        {
            /* These commands require a response */
            ControllerCommand = Data;
            StatusRegister |= PS2_STAT_COMMAND;
            break;
        }
 
        /* Disable second PS/2 port */
        case 0xA7:
        {
            ControllerConfig |= PS2_CONFIG_AUX_DISABLE;
            Ports[1].IsEnabled = FALSE;
            break;
        }
 
        /* Enable second PS/2 port */
        case 0xA8:
        {
            ControllerConfig &= ~PS2_CONFIG_AUX_DISABLE;
            Ports[1].IsEnabled = TRUE;
            break;
        }
 
        /* Test second PS/2 port */
        case 0xA9:
        {
            OutputBuffer = 0x00; // Success code
            StatusRegister |= PS2_STAT_OUT_BUF_FULL;
            break;
        }
 
        /* Test PS/2 controller */
        case 0xAA:
        {
            OutputBuffer = 0x55; // Success code
            StatusRegister |= PS2_STAT_OUT_BUF_FULL;
            break;
        }
 
        /* Test first PS/2 port */
        case 0xAB:
        {
            OutputBuffer = 0x00; // Success code
            StatusRegister |= PS2_STAT_OUT_BUF_FULL;
            break;
        }
 
        /* Disable first PS/2 port */
        case 0xAD:
        {
            ControllerConfig |= PS2_CONFIG_KBD_DISABLE;
            Ports[0].IsEnabled = FALSE;
            break;
        }
 
        /* Enable first PS/2 port */
        case 0xAE:
        {
            ControllerConfig &= ~PS2_CONFIG_KBD_DISABLE;
            Ports[0].IsEnabled = TRUE;
            break;
        }
 
        /* Read controller output port */
        case 0xD0:
        {
            /* Bit 0 always set, and bit 1 is the A20 gate state */
            OutputBuffer = (!!EmulatorGetA20() << 1) | PS2_OUT_CPU_NO_RESET;
 
            /* Set IRQ1 state */
            if (ControllerConfig & PS2_CONFIG_KBD_INT)
                OutputBuffer |=  PS2_OUT_IRQ01;
            else
                OutputBuffer &= ~PS2_OUT_IRQ01;
 
            /* Set IRQ12 state */
            if (ControllerConfig & PS2_CONFIG_AUX_INT)
                OutputBuffer |=  PS2_OUT_IRQ12;
            else
                OutputBuffer &= ~PS2_OUT_IRQ12;
 
            /* Check whether data is already present */
            if (StatusRegister & PS2_STAT_OUT_BUF_FULL)
            {
                if (StatusRegister & PS2_STAT_AUX_OUT_BUF_FULL)
                    OutputBuffer |= PS2_OUT_AUX_DATA;
                else
                    OutputBuffer |= PS2_OUT_KBD_DATA;
            }
 
            StatusRegister |= PS2_STAT_OUT_BUF_FULL;
            break;
        }
 
        /* CPU Reset */
        case 0xF0: case 0xF2: case 0xF4: case 0xF6:
        case 0xF8: case 0xFA: case 0xFC: case 0xFE:
        {
            /* Stop the VDM */
            EmulatorTerminate();
            return;
        }
    }
}

Referenced by PS2Initialize().

PS2WriteData()

static VOID WINAPI PS2WriteData ( USHORT  Port, BYTE  Data  )

static

Definition at line 278 of file ps2.c.

{
    /* Check if the controller is waiting for a response */
    if (StatusRegister & PS2_STAT_COMMAND)
    {
        StatusRegister &= ~PS2_STAT_COMMAND;
 
        /* Check which command it was */
        switch (ControllerCommand)
        {
            /* Write configuration byte (byte 0 from internal memory) */
            case 0x60:
            {
                ControllerConfig = Data;
 
                /*
                 * Synchronize the enable state of the PS/2 ports
                 * with the flags in the configuration byte.
                 */
                Ports[0].IsEnabled = !(ControllerConfig & PS2_CONFIG_KBD_DISABLE);
                Ports[1].IsEnabled = !(ControllerConfig & PS2_CONFIG_AUX_DISABLE);
 
                /*
                 * Update the "System enabled" flag of the status register
                 * with bit 2 of the controller configuration byte.
                 * See: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-11.html#kccb2
                 * for more details.
                 */
                if (ControllerConfig & PS2_CONFIG_SYSTEM)
                    StatusRegister |=  PS2_STAT_SYSTEM;
                else
                    StatusRegister &= ~PS2_STAT_SYSTEM;
 
                /*
                 * Update the "Keyboard enable" flag of the status register
                 * with the "Ignore keyboard lock" flag of the controller
                 * configuration byte (if set), then reset the latter one.
                 * See: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-11.html#kccb3
                 * for more details.
                 */
                if (ControllerConfig & PS2_CONFIG_NO_KEYLOCK)
                {
                    ControllerConfig &= ~PS2_CONFIG_NO_KEYLOCK;
                    StatusRegister   |=  PS2_STAT_KBD_ENABLE;
                }
 
                break;
            }
 
            /* Write to byte N of internal memory */
                       case 0x61: case 0x62: case 0x63:
            case 0x64: case 0x65: case 0x66: case 0x67:
            case 0x68: case 0x69: case 0x6A: case 0x6B:
            case 0x6C: case 0x6D: case 0x6E: case 0x6F:
            case 0x70: case 0x71: case 0x72: case 0x73:
            case 0x74: case 0x75: case 0x76: case 0x77:
            case 0x78: case 0x79: case 0x7A: case 0x7B:
            case 0x7C: case 0x7D: case 0x7E: case 0x7F:
            {
                Memory[ControllerCommand & 0x1F] = Data;
                break;
            }
 
            /* Write controller output */
            case 0xD1:
            {
                /* Check if bit 0 is unset */
                if (!(Data & PS2_OUT_CPU_NO_RESET))
                {
                    /* CPU disabled - Stop the VDM */
                    EmulatorTerminate();
                    return;
                }
 
                /* Update the A20 line setting */
                EmulatorSetA20(Data & PS2_OUT_A20_SET);
 
                // FIXME: Should we need to add the status of IRQ1 and IRQ12??
 
                break;
            }
 
            /* Push the data byte into the first PS/2 port queue */
            case 0xD2:
            {
                PS2QueuePush(0, Data);
                break;
            }
 
            /* Push the data byte into the second PS/2 port queue */
            case 0xD3:
            {
                PS2QueuePush(1, Data);
                break;
            }
 
            /*
             * Send a command to the second PS/2 port (by default
             * it is a command for the first PS/2 port)
             */
            case 0xD4:
            {
                PS2SendCommand(1, Data);
                break;
            }
        }
 
        return;
    }
 
    /* By default, send a command to the first PS/2 port */
    PS2SendCommand(0, Data);
}

Referenced by PS2Initialize().

Variable Documentation

ControllerCommand

BYTE ControllerCommand = 0x00

static

Definition at line 61 of file ps2.c.

Referenced by PS2WriteControl(), and PS2WriteData().

IrqTimer

PHARDWARE_TIMER IrqTimer = NULL

static

Definition at line 63 of file ps2.c.

Referenced by PS2Cleanup(), PS2Initialize(), and PS2QueuePush().

Memory

BYTE Memory[0x20]

static

Definition at line 54 of file ps2.c.

OutputBuffer

BYTE OutputBuffer = 0x00

static

Definition at line 59 of file ps2.c.

Referenced by PS2ReadData().

Ports

PS2_PORT Ports[PS2_PORTS]

static

Definition at line 52 of file ps2.c.

Referenced by IsaPnpCreateReadPortDORequirements(), IsaPnpCreateReadPortDOResources(), PS2Cleanup(), PS2Initialize(), PS2PortQueueRead(), PS2QueuePush(), PS2SendCommand(), PS2SetDeviceCmdProc(), PS2WriteControl(), and PS2WriteData().

StatusRegister

BYTE StatusRegister = 0x00

static

Definition at line 57 of file ps2.c.

Referenced by BusLogic_Command(), BusLogic_HardwareResetHostAdapter(), BusLogic_ProbeHostAdapter(), PS2PortQueueRead(), PS2ReadControl(), PS2ReadData(), PS2WriteControl(), PS2WriteData(), and UhciTakeControlHC().