/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    vdmentry.c

Abstract:

    This function dispatches to the vdm services

Author:

    Dave Hastings (daveh) 6-Apr-1992

Notes:

    This module will be fleshed out when the great vdm code consolidation
    occurs, sometime soon after the functionality is done.

Revision History:

     24-Sep-1993 Jonle: reoptimize dispatcher to suit the number of services
                        add QueueInterrupt service

--*/

#include "vdmp.h"
#include <ntvdmp.h>

ULONG VdmpMaxPMCliTime;
#if DISABLE_CLI
ULONG VdmpPMCliCount;
#endif

BOOLEAN
VdmpIsVdmProcess(
    VOID
    );

VOID
VdmpEnableOPL2 (
    ULONG BasePort
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, VdmpIsVdmProcess)
#pragma alloc_text(PAGE, NtVdmControl)
#pragma alloc_text(PAGE, VdmpEnableOPL2)
#endif

#if DBG
ULONG VdmInjectFailures;
#endif

BOOLEAN
VdmpIsVdmProcess(
    VOID
    )

/*++

Routine Description:

    This function verifies the caller is a VDM process.

Arguments:

    None.

Return Value:

    True if the caller is a VDM process.
    False if not
--*/

{
    PEPROCESS Process;
    PVDM_TIB VdmTib;
    NTSTATUS Status;

    PAGED_CODE();

    Process = PsGetCurrentProcess();

    if (Process->VdmObjects == NULL) {
        return FALSE;
    }

    //
    // Make sure the current thread has valid vdmtib.
    //

    Status = VdmpGetVdmTib(&VdmTib);
    if (!NT_SUCCESS(Status)) {
       return(FALSE);
    }

    //
    // More checking here ...
    //

    return TRUE;
}

NTSTATUS
NtVdmControl(
    IN VDMSERVICECLASS Service,
    IN OUT PVOID ServiceData
    )
/*++

Routine Description:

    386 specific routine which dispatches to the appropriate function
    based on service number.

Arguments:

    Service -- Specifies what service is to be performed
    ServiceData -- Supplies a pointer to service specific data

Return Value:

    if invalid service number: STATUS_INVALID_PARAMETER_1
    else see individual services.


--*/
{
    NTSTATUS Status;
    PVDM_PROCESS_OBJECTS pVdmObjects;
    VDM_INITIALIZE_DATA CapturedVdmInitializeData;

    PAGED_CODE();

    //
    // Make sure the caller is ntvdm.  Except ...
    //     VdmStartExecution - video driver uses it to support int 10
    //     VdmInitialize     - the vdm state is not fully initialized to
    //                         perform the check
    //

    if ((Service != VdmInitialize) &&
        (Service != VdmStartExecution) &&
        (PsGetCurrentProcess()->VdmObjects == NULL)) {

        return STATUS_ACCESS_DENIED;
    }

    try {

        //
        //  Dispatch in descending order of frequency
        //
        if (Service == VdmStartExecution) {
            Status = VdmpStartExecution();
        } else if (Service == VdmQueueInterrupt) {
            Status = VdmpQueueInterrupt(ServiceData);
        } else if (Service == VdmDelayInterrupt) {
            Status = VdmpDelayInterrupt(ServiceData);
        } else if (Service == VdmQueryDir) {
            Status = VdmQueryDirectoryFile(ServiceData);
        } else if (Service == VdmInitialize) {
            VdmpMaxPMCliTime = 1;
            ProbeForRead(ServiceData, sizeof(VDM_INITIALIZE_DATA), 1);
            RtlCopyMemory (&CapturedVdmInitializeData, ServiceData, sizeof (VDM_INITIALIZE_DATA));
            Status = VdmpInitialize(&CapturedVdmInitializeData);
        } else if (Service == VdmFeatures) {
            //
            // Verify that we were passed a valid user address
            //
            ProbeForWriteBoolean((PBOOLEAN)ServiceData);

            //
            // Return the appropriate feature bits to notify
            // ntvdm which modes (if any) fast IF emulation is
            // available for
            //
            if (KeI386VdmIoplAllowed) {
                *((PULONG)ServiceData) = V86_VIRTUAL_INT_EXTENSIONS;
            } else {
                // remove this if pm extensions to be used
                *((PULONG)ServiceData) = KeI386VirtualIntExtensions &
                    ~PM_VIRTUAL_INT_EXTENSIONS;
            }

            Status = STATUS_SUCCESS;

        } else if (Service == VdmSetInt21Handler) {
            ProbeForRead(ServiceData, sizeof(VDMSET_INT21_HANDLER_DATA), 1);

            Status = Ke386SetVdmInterruptHandler(
                KeGetCurrentThread()->ApcState.Process,
                0x21L,
                (USHORT)(((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Selector),
                ((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Offset,
                ((PVDMSET_INT21_HANDLER_DATA)ServiceData)->Gate32
                );

        } else if (Service == VdmPrinterDirectIoOpen) {
            Status = VdmpPrinterDirectIoOpen(ServiceData);
        } else if (Service == VdmPrinterDirectIoClose) {
            Status = VdmpPrinterDirectIoClose(ServiceData);
        } else if (Service == VdmPrinterInitialize) {
            Status = VdmpPrinterInitialize(ServiceData);
        } else if (Service == VdmSetLdtEntries && VdmpIsVdmProcess()) {
            ProbeForRead(ServiceData, sizeof(VDMSET_LDT_ENTRIES_DATA), 1);

            Status = VdmpSetLdtEntries(
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Selector0,
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry0Low,
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry0Hi,
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Selector1,
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry1Low,
                ((PVDMSET_LDT_ENTRIES_DATA)ServiceData)->Entry1Hi
                );
        } else if (Service == VdmSetProcessLdtInfo && VdmpIsVdmProcess()) {
            PPROCESS_LDT_INFORMATION ldtInfo;
            ULONG length;

            ProbeForRead(ServiceData, sizeof(VDMSET_PROCESS_LDT_INFO_DATA), 1);

            ldtInfo = ((PVDMSET_PROCESS_LDT_INFO_DATA)ServiceData)->LdtInformation;
            length = ((PVDMSET_PROCESS_LDT_INFO_DATA)ServiceData)->LdtInformationLength;

            ProbeForRead(ldtInfo, length, 1);
            Status = VdmpSetProcessLdtInfo(ldtInfo, length);
        } else if (Service == VdmAdlibEmulation && VdmpIsVdmProcess()) {
            //
            // Ntvdm calls here to do adlib emulation under the following conditions:
            //   ADLIB_DIRECT_IO - only If a FM synth device is opened for exclusive access.
            //   ADLIB_KERNEL_EMULATION - otherwise.
            //   Note ADLIB_USER_EMULATION is defaulted.  It is basically used by external
            //   ADLIB/SB vdds.
            //
            ProbeForRead(ServiceData, sizeof(VDM_ADLIB_DATA), 1);
            pVdmObjects = PsGetCurrentProcess()->VdmObjects;

            pVdmObjects->AdlibAction        = ((PVDM_ADLIB_DATA)ServiceData)->Action;
            pVdmObjects->AdlibPhysPortStart = ((PVDM_ADLIB_DATA)ServiceData)->PhysicalPortStart;
            pVdmObjects->AdlibPhysPortEnd   = ((PVDM_ADLIB_DATA)ServiceData)->PhysicalPortEnd;
            pVdmObjects->AdlibVirtPortStart = ((PVDM_ADLIB_DATA)ServiceData)->VirtualPortStart;
            pVdmObjects->AdlibVirtPortEnd   = ((PVDM_ADLIB_DATA)ServiceData)->VirtualPortEnd;
            pVdmObjects->AdlibIndexRegister = 0;
            pVdmObjects->AdlibStatus        = 0x6;  // OPL2 emulation

            if (pVdmObjects->AdlibAction == ADLIB_DIRECT_IO) {
                VdmpEnableOPL2(pVdmObjects->AdlibPhysPortStart);
            }
            Status = STATUS_SUCCESS;
        } else if (Service == VdmPMCliControl) {
            pVdmObjects = PsGetCurrentProcess()->VdmObjects;
            ProbeForRead(ServiceData, sizeof(VDM_PM_CLI_DATA), 1);

            Status = STATUS_SUCCESS;
            switch (((PVDM_PM_CLI_DATA)ServiceData)->Control) {
            case PM_CLI_CONTROL_DISABLE:
                pVdmObjects->VdmControl &= ~PM_CLI_CONTROL;
                break;
            case PM_CLI_CONTROL_ENABLE:
                pVdmObjects->VdmControl |= PM_CLI_CONTROL;
#if DISABLE_CLI
                VdmpPMCliCount = 0;
#endif
                if ((*FIXED_NTVDMSTATE_LINEAR_PC_AT & VDM_VIRTUAL_INTERRUPTS) == 0) {
                    VdmSetPMCliTimeStamp(TRUE);
                }
                break;
            case PM_CLI_CONTROL_CHECK:
                VdmCheckPMCliTimeStamp();
                break;
            case PM_CLI_CONTROL_SET:
                VdmSetPMCliTimeStamp(FALSE);
                break;
            case PM_CLI_CONTROL_CLEAR:
                VdmClearPMCliTimeStamp();
                break;
            default:
                Status = STATUS_INVALID_PARAMETER_1;
            }
        } else {
            Status = STATUS_INVALID_PARAMETER_1;
        }
    } except (EXCEPTION_EXECUTE_HANDLER) {
        Status = GetExceptionCode();
    }
#if DBG
    if (PsGetCurrentProcess()->VdmObjects != NULL) {
        if (VdmInjectFailures != 0) {
            PS_SET_BITS (&PsGetCurrentProcess()->Flags,
                         PS_PROCESS_INJECT_INPAGE_ERRORS);
        }
    }
#endif

    ASSERT(KeGetCurrentIrql () == PASSIVE_LEVEL);
    return Status;

}

VOID
VdmpEnableOPL2 (
    ULONG BasePort
    )

/*++

Routine Description:

    This routine checks if OPL3 is present.  If yes, it will set it OPL2
    mode.

    Note, According to OPL3 programming guide, we don't need to worry about
    the delay between ins and outs (back to back IOs).  In fact, I found out
    it needs a little bit delay.  When I code this routine in assembly,
    it does not work.  So, we may need to add a little more delay here if
    OPL2 stops working on some audio cards.

Arguments:

    BasePort - adlib base port

Return Value:

    None.


--*/
{
    UCHAR ch;
    PUCHAR SecondaryPort;

    ch = READ_PORT_UCHAR((PUCHAR)BasePort);
    if (ch == 0) {          // if OPL3
        SecondaryPort = (PUCHAR)(BasePort + 2); // move to secondary ports
        WRITE_PORT_UCHAR(SecondaryPort, 5);     // Select index register 5
        ch = READ_PORT_UCHAR((PUCHAR)BasePort); // a little bit delay
        WRITE_PORT_UCHAR(SecondaryPort + 1, 0);     // Select index register 5
    }
}

VOID
VdmCheckPMCliTimeStamp (
    VOID
    )

/*++

Routine Description:

    This routine checks if interrupts are disabled for too long by protected
    mode apps.  If ints are disabled for over predefined limit, they will be
    reenabled such that ntvdm will be able to dispatch pending interrupts.

    Note, V86 mode should NOT call this function.

Arguments:

    None.

Return Value:

    None.


--*/
{
    PVDM_PROCESS_OBJECTS pVdmObjects;
    PKPROCESS process = (PKPROCESS)PsGetCurrentProcess();
    NTSTATUS status;
    PVDM_TIB vdmTib;

    pVdmObjects = ((PEPROCESS)process)->VdmObjects;
    if (pVdmObjects->VdmControl & PM_CLI_CONTROL &&
        pVdmObjects->PMCliTimeStamp != 0) {
        if (((process->UserTime + 1)- pVdmObjects->PMCliTimeStamp) >= VdmpMaxPMCliTime) {
            pVdmObjects->PMCliTimeStamp = 0;
#if DISABLE_CLI
            VdmpPMCliCount++;
#endif
            try {

                *FIXED_NTVDMSTATE_LINEAR_PC_AT |= VDM_VIRTUAL_INTERRUPTS;
                status = VdmpGetVdmTib(&vdmTib);
                if (NT_SUCCESS(status)) {
                    vdmTib->VdmContext.EFlags |= EFLAGS_INTERRUPT_MASK;
                }
            } except(ExSystemExceptionFilter()) {
                status = GetExceptionCode();
            }
        }
    }
}

VOID
VdmSetPMCliTimeStamp (
    BOOLEAN Reset
    )

/*++

Routine Description:

    This routine checks if interrupts are disabled for too long by protected
    mode apps.  If ints are disabled for over predefined limit, they will be
    reenabled such that ntvdm will be able to dispatch pending interrupts.

    Note, V86 mode should NOT call this function.

Arguments:

    Reset - a Bool value to indicate should we re-set the count if it is not zero

Return Value:

    None.


--*/
{
    PVDM_PROCESS_OBJECTS pVdmObjects;
    PKPROCESS process = (PKPROCESS)PsGetCurrentProcess();

#if DISABLE_CLI
    if (VdmpPMCliCount > 0x20) {
        try {
            *FIXED_NTVDMSTATE_LINEAR_PC_AT |= VDM_VIRTUAL_INTERRUPTS;
        }
        except (EXCEPTION_EXECUTE_HANDLER) {
            NOTHING;
        }
        return;
    }
#endif
    pVdmObjects = ((PEPROCESS)process)->VdmObjects;
    if (pVdmObjects->VdmControl & PM_CLI_CONTROL) {
        if (Reset || pVdmObjects->PMCliTimeStamp == 0) {
            pVdmObjects->PMCliTimeStamp = process->UserTime + 1;
        }
    }
}

VOID
VdmClearPMCliTimeStamp (
    VOID
    )

/*++

Routine Description:

    This routine checks if interrupts are disabled for too long by protected
    mode apps.  If ints are disabled for over predefined limit, they will be
    reenabled such that ntvdm will be able to dispatch pending interrupts.

    Note, V86 mode should NOT call this function.

Arguments:

    None.

Return Value:

    None.


--*/
{
    PVDM_PROCESS_OBJECTS pVdmObjects;

    pVdmObjects = PsGetCurrentProcess()->VdmObjects;
    if (pVdmObjects->VdmControl & PM_CLI_CONTROL) {
        pVdmObjects->PMCliTimeStamp = 0;
    }
}