io.c File Reference

#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "io.h"

Include dependency graph for io.c:

Go to the source code of this file.

Classes
struct	_EMULATOR_IO_HANDLERS
struct	_EMULATOR_IOPORT_HANDLERS

Macros
#define	NDEBUG

Typedefs
typedef struct _EMULATOR_IO_HANDLERS	EMULATOR_IO_HANDLERS
typedef struct _EMULATOR_IO_HANDLERS *	PEMULATOR_IO_HANDLERS
typedef struct _EMULATOR_IOPORT_HANDLERS	EMULATOR_IOPORT_HANDLERS
typedef struct _EMULATOR_IOPORT_HANDLERS *	PEMULATOR_IOPORT_HANDLERS

Functions
UCHAR	IOReadB (USHORT Port)
VOID	IOReadStrB (USHORT Port, PUCHAR Buffer, ULONG Count)
VOID	IOWriteB (USHORT Port, UCHAR Buffer)
VOID	IOWriteStrB (USHORT Port, PUCHAR Buffer, ULONG Count)
USHORT	IOReadW (USHORT Port)
VOID	IOReadStrW (USHORT Port, PUSHORT Buffer, ULONG Count)
VOID	IOWriteW (USHORT Port, USHORT Buffer)
VOID	IOWriteStrW (USHORT Port, PUSHORT Buffer, ULONG Count)
ULONG	IOReadD (USHORT Port)
VOID	IOReadStrD (USHORT Port, PULONG Buffer, ULONG Count)
VOID	IOWriteD (USHORT Port, ULONG Buffer)
VOID	IOWriteStrD (USHORT Port, PULONG Buffer, ULONG Count)
VOID	RegisterIoPort (USHORT Port, EMULATOR_INB_PROC InHandler, EMULATOR_OUTB_PROC OutHandler)
VOID	UnregisterIoPort (USHORT Port)
VOID FASTCALL	EmulatorReadIo (PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
VOID FASTCALL	EmulatorWriteIo (PFAST486_STATE State, USHORT Port, PVOID Buffer, ULONG DataCount, UCHAR DataSize)
BOOL WINAPI	VDDInstallIOHook (IN HANDLE hVdd, IN WORD cPortRange, IN PVDD_IO_PORTRANGE pPortRange, IN PVDD_IO_HANDLERS IoHandlers)
VOID WINAPI	VDDDeInstallIOHook (IN HANDLE hVdd, IN WORD cPortRange, IN PVDD_IO_PORTRANGE pPortRange)

Variables
EMULATOR_IOPORT_HANDLERS	IoPortProc [EMULATOR_MAX_IOPORTS_NUM] = {{NULL}}

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file io.c.

Typedef Documentation

EMULATOR_IO_HANDLERS

typedef struct _EMULATOR_IO_HANDLERS EMULATOR_IO_HANDLERS

EMULATOR_IOPORT_HANDLERS

typedef struct _EMULATOR_IOPORT_HANDLERS EMULATOR_IOPORT_HANDLERS

PEMULATOR_IO_HANDLERS

typedef struct _EMULATOR_IO_HANDLERS * PEMULATOR_IO_HANDLERS

PEMULATOR_IOPORT_HANDLERS

typedef struct _EMULATOR_IOPORT_HANDLERS * PEMULATOR_IOPORT_HANDLERS

Function Documentation

EmulatorReadIo()

VOID FASTCALL EmulatorReadIo	(	PFAST486_STATE	State,
		USHORT	Port,
		PVOID	Buffer,
		ULONG	DataCount,
		UCHAR	DataSize
	)

Definition at line 349 of file io.c.

{
    UNREFERENCED_PARAMETER(State);

    if (DataSize == 0 || DataCount == 0) return;

    if (DataSize == sizeof(UCHAR))
    {
        if (DataCount == 1)
            *(PUCHAR)Buffer = IOReadB(Port);
        else
            IOReadStrB(Port, Buffer, DataCount);
    }
    else if (DataSize == sizeof(USHORT))
    {
        if (DataCount == 1)
            *(PUSHORT)Buffer = IOReadW(Port);
        else
            IOReadStrW(Port, Buffer, DataCount);
    }
    else if (DataSize == sizeof(ULONG))
    {
        if (DataCount == 1)
            *(PULONG)Buffer = IOReadD(Port);
        else
            IOReadStrD(Port, Buffer, DataCount);
    }
    else
    {
        PUCHAR Address = (PUCHAR)Buffer;

        while (DataCount--)
        {
            ULONG CurrentPort = Port;
            ULONG Count;
            UCHAR NewDataSize = DataSize;

            /* Read dword */
            Count       = NewDataSize >> 2; // NewDataSize / sizeof(ULONG);
            NewDataSize = NewDataSize  & 3; // NewDataSize % sizeof(ULONG);
            while (Count--)
            {
                *(PULONG)Address = IOReadD(CurrentPort);
                CurrentPort += sizeof(ULONG);
                Address     += sizeof(ULONG);
            }

            /* Read word */
            Count       = NewDataSize >> 1; // NewDataSize / sizeof(USHORT);
            NewDataSize = NewDataSize  & 1; // NewDataSize % sizeof(USHORT);
            while (Count--)
            {
                *(PUSHORT)Address = IOReadW(CurrentPort);
                CurrentPort += sizeof(USHORT);
                Address     += sizeof(USHORT);
            }

            /* Read byte */
            Count       = NewDataSize; // NewDataSize / sizeof(UCHAR);
            // NewDataSize = NewDataSize % sizeof(UCHAR);
            while (Count--)
            {
                *(PUCHAR)Address = IOReadB(CurrentPort);
                CurrentPort += sizeof(UCHAR);
                Address     += sizeof(UCHAR);
            }
        }
    }
}

Referenced by CpuInitialize().

EmulatorWriteIo()

VOID FASTCALL EmulatorWriteIo	(	PFAST486_STATE	State,
		USHORT	Port,
		PVOID	Buffer,
		ULONG	DataCount,
		UCHAR	DataSize
	)

Definition at line 424 of file io.c.

{
    UNREFERENCED_PARAMETER(State);

    if (DataSize == 0 || DataCount == 0) return;

    if (DataSize == sizeof(UCHAR))
    {
        if (DataCount == 1)
            IOWriteB(Port, *(PUCHAR)Buffer);
        else
            IOWriteStrB(Port, Buffer, DataCount);
    }
    else if (DataSize == sizeof(USHORT))
    {
        if (DataCount == 1)
            IOWriteW(Port, *(PUSHORT)Buffer);
        else
            IOWriteStrW(Port, Buffer, DataCount);
    }
    else if (DataSize == sizeof(ULONG))
    {
        if (DataCount == 1)
            IOWriteD(Port, *(PULONG)Buffer);
        else
            IOWriteStrD(Port, Buffer, DataCount);
    }
    else
    {
        PUCHAR Address = (PUCHAR)Buffer;

        while (DataCount--)
        {
            ULONG CurrentPort = Port;
            ULONG Count;
            UCHAR NewDataSize = DataSize;

            /* Write dword */
            Count       = NewDataSize >> 2; // NewDataSize / sizeof(ULONG);
            NewDataSize = NewDataSize  & 3; // NewDataSize % sizeof(ULONG);
            while (Count--)
            {
                IOWriteD(CurrentPort, *(PULONG)Address);
                CurrentPort += sizeof(ULONG);
                Address     += sizeof(ULONG);
            }

            /* Write word */
            Count       = NewDataSize >> 1; // NewDataSize / sizeof(USHORT);
            NewDataSize = NewDataSize  & 1; // NewDataSize % sizeof(USHORT);
            while (Count--)
            {
                IOWriteW(CurrentPort, *(PUSHORT)Address);
                CurrentPort += sizeof(USHORT);
                Address     += sizeof(USHORT);
            }

            /* Write byte */
            Count       = NewDataSize; // NewDataSize / sizeof(UCHAR);
            // NewDataSize = NewDataSize % sizeof(UCHAR);
            while (Count--)
            {
                IOWriteB(CurrentPort, *(PUCHAR)Address);
                CurrentPort += sizeof(UCHAR);
                Address     += sizeof(UCHAR);
            }
        }
    }
}

Referenced by CpuInitialize().

IOReadB()

UCHAR IOReadB

(

USHORT

Port

)

Definition at line 64 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InB)
    {
        return IoPortProc[Port].IoHandlers.InB(Port);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.inb_handler)
    {
        UCHAR Data;
        ASSERT(Port <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.inb_handler(Port, &Data);
        return Data;
    }
    else
    {
        /* Return an empty port byte value */
        DPRINT("Read from unknown port: 0x%X\n", Port);
        return 0xFF;
    }
}

Referenced by Bios32Post(), BiosBootstrapLoader(), BiosHandleMasterPicIRQ(), BiosHandleSlavePicIRQ(), BiosKeyboardIrq(), BiosMiscService(), BiosTimeService(), DisableMouseInt(), DosMouseIrq(), EmulatorReadIo(), EnableMouseInt(), EraseMouseCursor(), InitializeBiosData(), IOReadStrB(), IOReadW(), PaintMouseCursor(), PicSetIRQMask(), ReadMouseData(), VbeInitialize(), VbeResetExtendedRegisters(), VbeService(), VbeSetExtendedRegisters(), VgaSetRegisters(), VgaSetSinglePaletteRegister(), VidBiosClearScreen(), VidBiosDrawGlyph(), VidBiosSyncCursorPosition(), and VidBiosVideoService().

IOReadD()

ULONG IOReadD

(

USHORT

Port

)

Definition at line 252 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InD)
    {
        return IoPortProc[Port].IoHandlers.InD(Port);
    }
    else
    {
        USHORT Low, High;

        // FIXME: Is it ok on Little endian and Big endian ??
        Low  = IOReadW(Port);
        High = IOReadW(Port + sizeof(USHORT));
        return MAKELONG(Low, High);
    }
}

Referenced by EmulatorReadIo(), and IOReadStrD().

IOReadStrB()

VOID IOReadStrB	(	USHORT	Port,
		PUCHAR	Buffer,
		ULONG	Count
	)

Definition at line 88 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InsB)
    {
        IoPortProc[Port].IoHandlers.InsB(Port, Buffer, Count);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.insb_handler)
    {
        ASSERT(Port  <= MAXWORD);
        ASSERT(Count <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.insb_handler(Port, Buffer, (WORD)Count);
    }
    else
    {
        while (Count--) *Buffer++ = IOReadB(Port);
    }
}

Referenced by EmulatorReadIo().

IOReadStrD()

VOID IOReadStrD	(	USHORT	Port,
		PULONG	Buffer,
		ULONG	Count
	)

Definition at line 271 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InsD)
    {
        IoPortProc[Port].IoHandlers.InsD(Port, Buffer, Count);
    }
    else
    {
        while (Count--) *Buffer++ = IOReadD(Port);
    }
}

Referenced by EmulatorReadIo().

IOReadStrW()

VOID IOReadStrW	(	USHORT	Port,
		PUSHORT	Buffer,
		ULONG	Count
	)

Definition at line 183 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InsW)
    {
        IoPortProc[Port].IoHandlers.InsW(Port, Buffer, Count);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.insw_handler)
    {
        ASSERT(Port  <= MAXWORD);
        ASSERT(Count <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.insw_handler(Port, Buffer, (WORD)Count);
    }
    else
    {
        while (Count--) *Buffer++ = IOReadW(Port);
    }
}

Referenced by EmulatorReadIo().

IOReadW()

USHORT IOReadW

(

USHORT

Port

)

Definition at line 156 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.InW)
    {
        return IoPortProc[Port].IoHandlers.InW(Port);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.inw_handler)
    {
        USHORT Data;
        ASSERT(Port <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.inw_handler(Port, &Data);
        return Data;
    }
    else
    {
        UCHAR Low, High;

        // FIXME: Is it ok on Little endian and Big endian ??
        Low  = IOReadB(Port);
        High = IOReadB(Port + sizeof(UCHAR));
        return MAKEWORD(Low, High);
    }
}

Referenced by EmulatorReadIo(), IOReadD(), and IOReadStrW().

IOWriteB()

VOID IOWriteB	(	USHORT	Port,
		UCHAR	Buffer
	)

Definition at line 111 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutB)
    {
        IoPortProc[Port].IoHandlers.OutB(Port, Buffer);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.outb_handler)
    {
        ASSERT(Port <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.outb_handler(Port, Buffer);
    }
    else
    {
        /* Do nothing */
        DPRINT("Write to unknown port: 0x%X\n", Port);
    }
}

Referenced by Bios32Post(), BiosBootstrapLoader(), BiosHandleMasterPicIRQ(), BiosHandleSlavePicIRQ(), BiosHwSetup(), BiosMiscService(), BiosTimeService(), DisableMouseInt(), EmulatorWriteIo(), EnableMouseInt(), EraseMouseCursor(), InitializeBiosData(), IOWriteStrB(), IOWriteW(), MouseBios32Post(), PaintMouseCursor(), PicIRQComplete(), PicSetIRQMask(), SendMouseCommand(), VbeInitialize(), VbeResetExtendedRegisters(), VbeService(), VbeSetExtendedRegisters(), VgaSetPalette(), VgaSetRegisters(), VgaSetSinglePaletteRegister(), VidBiosClearScreen(), VidBiosDrawGlyph(), VidBiosSetCursorPosition(), VidBiosSetCursorShape(), VidBiosSetVideoMode(), VidBiosSetVideoPage(), VidBiosSyncCursorPosition(), and VidBiosVideoService().

IOWriteD()

VOID IOWriteD	(	USHORT	Port,
		ULONG	Buffer
	)

Definition at line 287 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutD)
    {
        IoPortProc[Port].IoHandlers.OutD(Port, Buffer);
    }
    else
    {
        // FIXME: Is it ok on Little endian and Big endian ??
        IOWriteW(Port, LOWORD(Buffer));
        IOWriteW(Port + sizeof(USHORT), HIWORD(Buffer));
    }
}

Referenced by EmulatorWriteIo(), and IOWriteStrD().

IOWriteStrB()

VOID IOWriteStrB	(	USHORT	Port,
		PUCHAR	Buffer,
		ULONG	Count
	)

Definition at line 133 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutsB)
    {
        IoPortProc[Port].IoHandlers.OutsB(Port, Buffer, Count);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.outsb_handler)
    {
        ASSERT(Port  <= MAXWORD);
        ASSERT(Count <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.outsb_handler(Port, Buffer, (WORD)Count);
    }
    else
    {
        while (Count--) IOWriteB(Port, *Buffer++);
    }
}

Referenced by EmulatorWriteIo().

IOWriteStrD()

VOID IOWriteStrD	(	USHORT	Port,
		PULONG	Buffer,
		ULONG	Count
	)

Definition at line 304 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutsD)
    {
        IoPortProc[Port].IoHandlers.OutsD(Port, Buffer, Count);
    }
    else
    {
        while (Count--) IOWriteD(Port, *Buffer++);
    }
}

Referenced by EmulatorWriteIo().

IOWriteStrW()

VOID IOWriteStrW	(	USHORT	Port,
		PUSHORT	Buffer,
		ULONG	Count
	)

Definition at line 229 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutsW)
    {
        IoPortProc[Port].IoHandlers.OutsW(Port, Buffer, Count);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.outsw_handler)
    {
        ASSERT(Port  <= MAXWORD);
        ASSERT(Count <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.outsw_handler(Port, Buffer, (WORD)Count);
    }
    else
    {
        while (Count--) IOWriteW(Port, *Buffer++);
    }
}

Referenced by EmulatorWriteIo().

IOWriteW()

VOID IOWriteW	(	USHORT	Port,
		USHORT	Buffer
	)

Definition at line 206 of file io.c.

{
    if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
        IoPortProc[Port].IoHandlers.OutW)
    {
        IoPortProc[Port].IoHandlers.OutW(Port, Buffer);
    }
    else if (IoPortProc[Port].hVdd != NULL && IoPortProc[Port].hVdd != INVALID_HANDLE_VALUE &&
             IoPortProc[Port].VddIoHandlers.outw_handler)
    {
        ASSERT(Port <= MAXWORD);
        IoPortProc[Port].VddIoHandlers.outw_handler(Port, Buffer);
    }
    else
    {
        // FIXME: Is it ok on Little endian and Big endian ??
        IOWriteB(Port, LOBYTE(Buffer));
        IOWriteB(Port + sizeof(UCHAR), HIBYTE(Buffer));
    }
}

Referenced by EmulatorWriteIo(), IOWriteD(), and IOWriteStrW().

RegisterIoPort()

VOID RegisterIoPort	(	USHORT	Port,
		EMULATOR_INB_PROC	InHandler,
		EMULATOR_OUTB_PROC	OutHandler
	)

Definition at line 320 of file io.c.

{
    if (IoPortProc[Port].IoHandlers.InB == NULL)
        IoPortProc[Port].IoHandlers.InB = InHandler;
    else
        DPRINT1("IoPortProc[0x%X].IoHandlers.InB already registered\n", Port);

    if (IoPortProc[Port].IoHandlers.OutB == NULL)
        IoPortProc[Port].IoHandlers.OutB = OutHandler;
    else
        DPRINT1("IoPortProc[0x%X].IoHandlers.OutB already registered\n", Port);

    /* We hold the I/O port internally */
    IoPortProc[Port].hVdd = INVALID_HANDLE_VALUE;
}

Referenced by CmosInitialize(), DmaInitialize(), PicInitialize(), PitInitialize(), PpiInitialize(), PS2Initialize(), VgaInitialize(), and VgaWritePort().

UnregisterIoPort()

VOID UnregisterIoPort

(

USHORT

Port

)

Definition at line 338 of file io.c.

{
    /*
     * Put automagically all the fields to zero:
     * the hVdd gets unregistered as well as all the handlers.
     */
    // IoPortProc[Port] = {NULL};
    RtlZeroMemory(&IoPortProc[Port], sizeof(IoPortProc[Port]));
}

Referenced by VgaWritePort().

VDDDeInstallIOHook()

VOID WINAPI VDDDeInstallIOHook	(	IN HANDLE	hVdd,
		IN WORD	cPortRange,
		IN PVDD_IO_PORTRANGE	pPortRange
	)

Definition at line 565 of file io.c.

{
    WORD i;

    /* Check validity of the VDD handle */
    if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return;
    }

    /* Loop for each range of I/O ports */
    while (cPortRange--)
    {
        /* Unregister the range of I/O ports */
        for (i = pPortRange->First; i <= pPortRange->Last; ++i)
        {
            /*
             * Don't do anything if we don't own the I/O port.
             */
            if (IoPortProc[i].hVdd != hVdd)
            {
                DPRINT1("IoPortProc[0x%X] owned by somebody else\n", i);
                continue;
            }

            /*
             * Put automagically all the fields to zero:
             * the hVdd gets unregistered as well as all the handlers.
             */
            // IoPortProc[i] = {NULL};
            RtlZeroMemory(&IoPortProc[i], sizeof(IoPortProc[i]));
        }

        /* Go to the next range */
        ++pPortRange;
    }
}

VDDInstallIOHook()

BOOL WINAPI VDDInstallIOHook	(	IN HANDLE	hVdd,
		IN WORD	cPortRange,
		IN PVDD_IO_PORTRANGE	pPortRange,
		IN PVDD_IO_HANDLERS	IoHandlers
	)

Definition at line 502 of file io.c.

{
    WORD i;

    /* Check validity of the VDD handle */
    if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    /* Loop for each range of I/O ports */
    while (cPortRange--)
    {
        /* Register the range of I/O ports */
        for (i = pPortRange->First; i <= pPortRange->Last; ++i)
        {
            /*
             * Don't do anything if the I/O port is already
             * handled internally or externally.
             */
            if (IoPortProc[i].hVdd != NULL)
            {
                DPRINT1("IoPortProc[0x%X] already registered\n", i);
                continue;
            }

            /* Register wrt. the VDD */
            IoPortProc[i].hVdd = hVdd;

            /* Disable the internal handlers */
            IoPortProc[i].IoHandlers.InB = NULL;
            IoPortProc[i].IoHandlers.InW = NULL;
            IoPortProc[i].IoHandlers.InD = NULL;

            IoPortProc[i].IoHandlers.InsB = NULL;
            IoPortProc[i].IoHandlers.InsW = NULL;
            IoPortProc[i].IoHandlers.InsD = NULL;

            IoPortProc[i].IoHandlers.OutB = NULL;
            IoPortProc[i].IoHandlers.OutW = NULL;
            IoPortProc[i].IoHandlers.OutD = NULL;

            IoPortProc[i].IoHandlers.OutsB = NULL;
            IoPortProc[i].IoHandlers.OutsW = NULL;
            IoPortProc[i].IoHandlers.OutsD = NULL;

            /* Save our handlers */
            IoPortProc[i].VddIoHandlers = *IoHandlers;
        }

        /* Go to the next range */
        ++pPortRange;
    }

    return TRUE;
}

Variable Documentation

IoPortProc

EMULATOR_IOPORT_HANDLERS IoPortProc[EMULATOR_MAX_IOPORTS_NUM] = {{NULL}}

Definition at line 59 of file io.c.

Referenced by IOReadB(), IOReadD(), IOReadStrB(), IOReadStrD(), IOReadStrW(), IOReadW(), IOWriteB(), IOWriteD(), IOWriteStrB(), IOWriteStrD(), IOWriteStrW(), IOWriteW(), RegisterIoPort(), UnregisterIoPort(), VDDDeInstallIOHook(), and VDDInstallIOHook().