device.c File Reference

#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "cpu/bop.h"
#include "device.h"
#include "dos.h"
#include "dos/dem.h"
#include "memory.h"

Include dependency graph for device.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	C_ASSERT ((sizeof(StrategyRoutine)+sizeof(InterruptRoutine))==DEVICE_CODE_SIZE)
static VOID	DosCallDriver (DWORD Driver, PDOS_REQUEST_HEADER Request)
static WORD NTAPI	DosDriverReadInternal (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length, BOOLEAN IoControl)
static WORD NTAPI	DosDriverWriteInternal (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length, BOOLEAN IoControl)
static WORD NTAPI	DosDriverGenericRequest (PDOS_DEVICE_NODE DeviceNode, BYTE CommandCode)
static WORD NTAPI	DosDriverDispatchIoctlRead (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
static WORD NTAPI	DosDriverDispatchRead (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
static WORD NTAPI	DosDriverDispatchPeek (PDOS_DEVICE_NODE DeviceNode, PBYTE Character)
static WORD NTAPI	DosDriverDispatchInputStatus (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchFlushInput (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchIoctlWrite (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
static WORD NTAPI	DosDriverDispatchWrite (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
static WORD NTAPI	DosDriverDispatchOutputStatus (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchFlushOutput (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchOpen (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchClose (PDOS_DEVICE_NODE DeviceNode)
static WORD NTAPI	DosDriverDispatchOutputUntilBusy (PDOS_DEVICE_NODE DeviceNode, DWORD Buffer, PWORD Length)
static VOID	DosAddDriver (DWORD Driver)
static VOID	DosRemoveDriver (DWORD Driver)
static PDOS_DEVICE_NODE	DosCreateDeviceNode (DWORD Driver)
PDOS_DEVICE_NODE	DosGetDriverNode (DWORD Driver)
PDOS_DEVICE_NODE	DosGetDevice (LPCSTR DeviceName)
PDOS_DEVICE_NODE	DosCreateDeviceEx (WORD Attributes, PCHAR DeviceName, WORD PrivateDataSize)
PDOS_DEVICE_NODE	DosCreateDevice (WORD Attributes, PCHAR DeviceName)
VOID	DosDeleteDevice (PDOS_DEVICE_NODE DeviceNode)
VOID	DeviceStrategyBop (VOID)
VOID	DeviceInterruptBop (VOID)
DWORD	DosLoadDriver (LPCSTR DriverFile)

Variables
static const BYTE	StrategyRoutine []
static const BYTE	InterruptRoutine []
static LIST_ENTRY	DeviceList = { &DeviceList, &DeviceList }
static PDOS_REQUEST_HEADER	DeviceRequest

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file device.c.

Function Documentation

C_ASSERT()

C_ASSERT

(

(sizeof(StrategyRoutine)+sizeof(InterruptRoutine))

= =DEVICE_CODE_SIZE

)

DeviceInterruptBop()

VOID DeviceInterruptBop

(

VOID

)

Definition at line 436 of file device.c.

{
    PLIST_ENTRY i;
    PDOS_DEVICE_NODE Node;
    DWORD DriverAddress = (getCS() << 4) + getIP() - sizeof(DOS_DRIVER) - 9;
 
    /* Get the device node for this driver */
    for (i = DeviceList.Flink; i != &DeviceList; i = i->Flink)
    {
        Node = CONTAINING_RECORD(i, DOS_DEVICE_NODE, Entry);
        if (TO_LINEAR(HIWORD(Node->Driver), LOWORD(Node->Driver)) == DriverAddress) break;
    }
 
    if (i == &DeviceList)
    {
        DPRINT1("Device interrupt BOP from an unknown location.\n");
        return;
    }
 
    switch (DeviceRequest->CommandCode)
    {
        case DOS_DEVCMD_IOCTL_READ:
        {
            PDOS_IOCTL_RW_REQUEST Request = (PDOS_IOCTL_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->IoctlReadRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_READ:
        {
            PDOS_RW_REQUEST Request = (PDOS_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->ReadRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_PEEK:
        {
            PDOS_PEEK_REQUEST Request = (PDOS_PEEK_REQUEST)DeviceRequest;
            DeviceRequest->Status = Node->PeekRoutine(Node, &Request->Character);
            break;
        }
 
        case DOS_DEVCMD_INSTAT:
        {
            DeviceRequest->Status = Node->InputStatusRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_FLUSH_INPUT:
        {
            DeviceRequest->Status = Node->FlushInputRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_IOCTL_WRITE:
        {
            PDOS_IOCTL_RW_REQUEST Request = (PDOS_IOCTL_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->IoctlWriteRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_WRITE:
        {
            PDOS_RW_REQUEST Request = (PDOS_RW_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->WriteRoutine(Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        case DOS_DEVCMD_OUTSTAT:
        {
            DeviceRequest->Status = Node->OutputStatusRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_FLUSH_OUTPUT:
        {
            DeviceRequest->Status = Node->FlushOutputRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_OPEN:
        {
            DeviceRequest->Status = Node->OpenRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_CLOSE:
        {
            DeviceRequest->Status = Node->CloseRoutine(Node);
            break;
        }
 
        case DOS_DEVCMD_OUTPUT_BUSY:
        {
            PDOS_OUTPUT_BUSY_REQUEST Request = (PDOS_OUTPUT_BUSY_REQUEST)DeviceRequest;
 
            DeviceRequest->Status = Node->OutputUntilBusyRoutine(
                Node,
                Request->BufferPointer,
                &Request->Length
            );
 
            break;
        }
 
        default:
        {
            DPRINT1("Unknown device command code: %u\n", DeviceRequest->CommandCode);
        }
    }
}

Referenced by DosSystemBop().

DeviceStrategyBop()

VOID DeviceStrategyBop

(

VOID

)

Definition at line 430 of file device.c.

{
    /* Save ES:BX */
    DeviceRequest = (PDOS_REQUEST_HEADER)SEG_OFF_TO_PTR(getES(), getBX());
}

Referenced by DosSystemBop().

DosAddDriver()

static VOID DosAddDriver ( DWORD  Driver )

static

Definition at line 228 of file device.c.

{
    PDOS_DRIVER LastDriver = &SysVars->NullDevice;
 
    /* Find the last driver in the list */
    while (LOWORD(LastDriver->Link) != 0xFFFF)
    {
        LastDriver = (PDOS_DRIVER)FAR_POINTER(LastDriver->Link);
    }
 
    /* Add the new driver to the list */
    LastDriver->Link = Driver;
    LastDriver = (PDOS_DRIVER)FAR_POINTER(Driver);
 
    if (LastDriver->DeviceAttributes & DOS_DEVATTR_CLOCK)
    {
        /* Update the active CLOCK driver */
        SysVars->ActiveClock = Driver;
    }
 
    if (LastDriver->DeviceAttributes
        & (DOS_DEVATTR_STDIN | DOS_DEVATTR_STDOUT | DOS_DEVATTR_CON))
    {
        /* Update the active CON driver */
        SysVars->ActiveCon = Driver;
    }
}

Referenced by DosCreateDeviceEx(), and DosLoadDriver().

DosCallDriver()

static VOID DosCallDriver ( DWORD  Driver, PDOS_REQUEST_HEADER  Request  )

static

Definition at line 49 of file device.c.

{
    PDOS_DRIVER DriverBlock = (PDOS_DRIVER)FAR_POINTER(Driver);
    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();
 
    /* Set ES:BX to the location of the request */
    setES(DOS_DATA_SEGMENT);
    setBX(DOS_DATA_OFFSET(Sda.Request));
 
    /* Copy the request structure to ES:BX */
    RtlMoveMemory(&Sda->Request, Request, Request->RequestLength);
 
    /* Call the strategy routine, and then the interrupt routine */
    RunCallback16(&DosContext, MAKELONG(DriverBlock->StrategyRoutine , HIWORD(Driver)));
    RunCallback16(&DosContext, MAKELONG(DriverBlock->InterruptRoutine, HIWORD(Driver)));
 
    /* Get the request structure from ES:BX */
    RtlMoveMemory(Request, &Sda->Request, Request->RequestLength);
 
    /* Restore the registers */
    setAX(AX);
    setCX(CX);
    setDX(DX);
    setBX(BX);
    setBP(BP);
    setSI(SI);
    setDI(DI);
    setDS(DS);
    setES(ES);
}

Referenced by DosDriverDispatchOutputUntilBusy(), DosDriverDispatchPeek(), DosDriverGenericRequest(), DosDriverReadInternal(), DosDriverWriteInternal(), and DosLoadDriver().

DosCreateDevice()

PDOS_DEVICE_NODE DosCreateDevice	(	WORD	Attributes,
		PCHAR	DeviceName
	)

Definition at line 413 of file device.c.

{
    /* Call the extended API */
    return DosCreateDeviceEx(Attributes, DeviceName, 0);
}

Referenced by ConDrvInitialize().

DosCreateDeviceEx()

PDOS_DEVICE_NODE DosCreateDeviceEx	(	WORD	Attributes,
		PCHAR	DeviceName,
		WORD	PrivateDataSize
	)

Definition at line 361 of file device.c.

{
    BYTE i;
    WORD Segment;
    PDOS_DRIVER DriverHeader;
    PDOS_DEVICE_NODE Node;
 
    /* Make sure this is a character device */
    if (!(Attributes & DOS_DEVATTR_CHARACTER))
    {
        DPRINT1("ERROR: Block devices are not supported.\n");
        return NULL;
    }
 
    /* Create a driver header for this device */
    Segment = DosAllocateMemory(sizeof(DOS_DRIVER) + DEVICE_CODE_SIZE + PrivateDataSize, NULL);
    if (Segment == 0) return NULL;
 
    /* Fill the header with data */
    DriverHeader = SEG_OFF_TO_PTR(Segment, 0);
    DriverHeader->Link = MAXDWORD;
    DriverHeader->DeviceAttributes = Attributes;
    DriverHeader->StrategyRoutine = sizeof(DOS_DRIVER);
    DriverHeader->InterruptRoutine = sizeof(DOS_DRIVER) + sizeof(StrategyRoutine);
 
    RtlFillMemory(DriverHeader->DeviceName, MAX_DEVICE_NAME, ' ');
    for (i = 0; i < MAX_DEVICE_NAME; i++)
    {
        if (DeviceName[i] == '\0' || DeviceName[i] == ' ') break;
        DriverHeader->DeviceName[i] = DeviceName[i];
    }
 
    /* Write the routines */
    RtlMoveMemory(SEG_OFF_TO_PTR(Segment, DriverHeader->StrategyRoutine),
                  StrategyRoutine,
                  sizeof(StrategyRoutine));
    RtlMoveMemory(SEG_OFF_TO_PTR(Segment, DriverHeader->InterruptRoutine),
                  InterruptRoutine,
                  sizeof(InterruptRoutine));
 
    /* Create the node */
    Node = DosCreateDeviceNode(MAKELONG(0, Segment));
    if (Node == NULL)
    {
        DosFreeMemory(Segment);
        return NULL;
    }
 
    DosAddDriver(Node->Driver);
    return Node;
}

Referenced by DosCreateDevice(), EmsDrvInitialize(), and XmsInitialize().

DosCreateDeviceNode()

static PDOS_DEVICE_NODE DosCreateDeviceNode ( DWORD  Driver )

static

Definition at line 275 of file device.c.

{
    BYTE i;
    PDOS_DRIVER DriverHeader = (PDOS_DRIVER)FAR_POINTER(Driver);
    PDOS_DEVICE_NODE Node = RtlAllocateHeap(RtlGetProcessHeap(),
                                            HEAP_ZERO_MEMORY,
                                            sizeof(*Node));
    if (Node == NULL) return NULL;
 
    Node->Driver = Driver;
    Node->DeviceAttributes = DriverHeader->DeviceAttributes;
 
    /* Initialize the name string */
    Node->Name.Buffer = Node->NameBuffer;
    Node->Name.MaximumLength = MAX_DEVICE_NAME;
 
    for (i = 0; i < MAX_DEVICE_NAME; i++)
    {
        if (DriverHeader->DeviceName[i] == ' ') break;
        Node->Name.Buffer[i] = DriverHeader->DeviceName[i];
    }
 
    Node->Name.Length = i;
 
    InsertTailList(&DeviceList, &Node->Entry);
    return Node;
}

Referenced by DosCreateDeviceEx(), DosGetDriverNode(), and DosLoadDriver().

DosDeleteDevice()

VOID DosDeleteDevice

(

PDOS_DEVICE_NODE

DeviceNode

)

Definition at line 419 of file device.c.

{
    DosRemoveDriver(DeviceNode->Driver);
 
    ASSERT(LOWORD(DeviceNode->Driver) == 0);
    DosFreeMemory(HIWORD(DeviceNode->Driver));
 
    RemoveEntryList(&DeviceNode->Entry);
    RtlFreeHeap(RtlGetProcessHeap(), 0, DeviceNode);
}

Referenced by ConDrvCleanup(), EmsDrvCleanup(), and XmsCleanup().

DosDriverDispatchClose()

static WORD NTAPI DosDriverDispatchClose ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 206 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_CLOSE);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchFlushInput()

static WORD NTAPI DosDriverDispatchFlushInput ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 172 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_FLUSH_INPUT);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchFlushOutput()

static WORD NTAPI DosDriverDispatchFlushOutput ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 196 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_FLUSH_OUTPUT);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchInputStatus()

static WORD NTAPI DosDriverDispatchInputStatus ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 167 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_INSTAT);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchIoctlRead()

static WORD NTAPI DosDriverDispatchIoctlRead ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length  )

static

Definition at line 139 of file device.c.

{
    return DosDriverReadInternal(DeviceNode, Buffer, Length, TRUE);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchIoctlWrite()

static WORD NTAPI DosDriverDispatchIoctlWrite ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length  )

static

Definition at line 177 of file device.c.

{
    return DosDriverWriteInternal(DeviceNode, Buffer, Length, TRUE);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchOpen()

static WORD NTAPI DosDriverDispatchOpen ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 201 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_OPEN);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchOutputStatus()

static WORD NTAPI DosDriverDispatchOutputStatus ( PDOS_DEVICE_NODE  DeviceNode )

static

Definition at line 191 of file device.c.

{
    return DosDriverGenericRequest(DeviceNode, DOS_DEVCMD_OUTSTAT);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchOutputUntilBusy()

static WORD NTAPI DosDriverDispatchOutputUntilBusy ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length  )

static

Definition at line 211 of file device.c.

{
    DOS_OUTPUT_BUSY_REQUEST Request;
 
    Request.Header.RequestLength = sizeof(DOS_OUTPUT_BUSY_REQUEST);
    Request.Header.CommandCode = DOS_DEVCMD_OUTPUT_BUSY;
    Request.BufferPointer = Buffer;
    Request.Length = *Length;
 
    DosCallDriver(DeviceNode->Driver, &Request.Header);
 
    *Length = Request.Length;
    return Request.Header.Status;
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchPeek()

static WORD NTAPI DosDriverDispatchPeek ( PDOS_DEVICE_NODE  DeviceNode, PBYTE  Character  )

static

Definition at line 153 of file device.c.

{
    DOS_PEEK_REQUEST Request;
 
    Request.Header.RequestLength = sizeof(DOS_PEEK_REQUEST);
    Request.Header.CommandCode = DOS_DEVCMD_PEEK;
 
    DosCallDriver(DeviceNode->Driver, &Request.Header);
 
    *Character = Request.Character;
    return Request.Header.Status;
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchRead()

static WORD NTAPI DosDriverDispatchRead ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length  )

static

Definition at line 146 of file device.c.

{
    return DosDriverReadInternal(DeviceNode, Buffer, Length, FALSE);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverDispatchWrite()

static WORD NTAPI DosDriverDispatchWrite ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length  )

static

Definition at line 184 of file device.c.

{
    return DosDriverWriteInternal(DeviceNode, Buffer, Length, FALSE);
}

Referenced by DosGetDriverNode(), and DosLoadDriver().

DosDriverGenericRequest()

static WORD NTAPI DosDriverGenericRequest ( PDOS_DEVICE_NODE  DeviceNode, BYTE  CommandCode  )

inlinestatic

Definition at line 126 of file device.c.

{
    DOS_REQUEST_HEADER Request;
 
    Request.RequestLength = sizeof(DOS_REQUEST_HEADER);
    Request.CommandCode = CommandCode;
 
    DosCallDriver(DeviceNode->Driver, &Request);
 
    return Request.Status;
}

Referenced by DosDriverDispatchClose(), DosDriverDispatchFlushInput(), DosDriverDispatchFlushOutput(), DosDriverDispatchInputStatus(), DosDriverDispatchOpen(), and DosDriverDispatchOutputStatus().

DosDriverReadInternal()

static WORD NTAPI DosDriverReadInternal ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length, BOOLEAN  IoControl  )

inlinestatic

Definition at line 88 of file device.c.

{
    DOS_RW_REQUEST Request;
 
    Request.Header.RequestLength = IoControl ? sizeof(DOS_IOCTL_RW_REQUEST)
                                             : sizeof(DOS_RW_REQUEST);
    Request.Header.CommandCode = IoControl ? DOS_DEVCMD_IOCTL_READ : DOS_DEVCMD_READ;
    Request.BufferPointer = Buffer;
    Request.Length = *Length;
 
    DosCallDriver(DeviceNode->Driver, &Request.Header);
 
    *Length = Request.Length;
    return Request.Header.Status;
}

Referenced by DosDriverDispatchIoctlRead(), and DosDriverDispatchRead().

DosDriverWriteInternal()

static WORD NTAPI DosDriverWriteInternal ( PDOS_DEVICE_NODE  DeviceNode, DWORD  Buffer, PWORD  Length, BOOLEAN  IoControl  )

inlinestatic

Definition at line 107 of file device.c.

{
    DOS_RW_REQUEST Request;
 
    Request.Header.RequestLength = IoControl ? sizeof(DOS_IOCTL_RW_REQUEST)
                                             : sizeof(DOS_RW_REQUEST);
    Request.Header.CommandCode = IoControl ? DOS_DEVCMD_IOCTL_WRITE : DOS_DEVCMD_WRITE;
    Request.BufferPointer = Buffer;
    Request.Length = *Length;
 
    DosCallDriver(DeviceNode->Driver, &Request.Header);
 
    *Length = Request.Length;
    return Request.Header.Status;
}

Referenced by DosDriverDispatchIoctlWrite(), and DosDriverDispatchWrite().

DosGetDevice()

PDOS_DEVICE_NODE DosGetDevice

(

LPCSTR

DeviceName

)

Definition at line 342 of file device.c.

{
    DWORD CurrentDriver = MAKELONG(DOS_DATA_OFFSET(SysVars.NullDevice), DOS_DATA_SEGMENT);
    ANSI_STRING DeviceNameString;
 
    RtlInitAnsiString(&DeviceNameString, DeviceName);
 
    while (LOWORD(CurrentDriver) != 0xFFFF)
    {
        PDOS_DEVICE_NODE Node = DosGetDriverNode(CurrentDriver);
        PDOS_DRIVER DriverHeader = (PDOS_DRIVER)FAR_POINTER(CurrentDriver);
 
        if (RtlEqualString(&Node->Name, &DeviceNameString, TRUE)) return Node;
        CurrentDriver = DriverHeader->Link;
    }
 
    return NULL;
}

Referenced by DosCreateFile(), DosCreateFileEx(), and DosOpenFile().

DosGetDriverNode()

PDOS_DEVICE_NODE DosGetDriverNode

(

DWORD

Driver

)

Definition at line 305 of file device.c.

{
    PLIST_ENTRY i;
    PDOS_DEVICE_NODE Node;
 
    for (i = DeviceList.Flink; i != &DeviceList; i = i->Flink)
    {
        Node = CONTAINING_RECORD(i, DOS_DEVICE_NODE, Entry);
        if (Node->Driver == Driver) break;
    }
 
    if (i == &DeviceList)
    {
        DPRINT1("The driver at %04X:%04X has no associated device node. "
                "Installing automagically.\n",
                HIWORD(Driver),
                LOWORD(Driver));
 
        /* Create the device node */
        Node = DosCreateDeviceNode(Driver);
        Node->IoctlReadRoutine = DosDriverDispatchIoctlRead;
        Node->ReadRoutine = DosDriverDispatchRead;
        Node->PeekRoutine = DosDriverDispatchPeek;
        Node->InputStatusRoutine = DosDriverDispatchInputStatus;
        Node->FlushInputRoutine = DosDriverDispatchFlushInput;
        Node->IoctlWriteRoutine = DosDriverDispatchIoctlWrite;
        Node->WriteRoutine = DosDriverDispatchWrite;
        Node->OutputStatusRoutine = DosDriverDispatchOutputStatus;
        Node->FlushOutputRoutine = DosDriverDispatchFlushOutput;
        Node->OpenRoutine = DosDriverDispatchOpen;
        Node->CloseRoutine = DosDriverDispatchClose;
        Node->OutputUntilBusyRoutine = DosDriverDispatchOutputUntilBusy;
    }
 
    return Node;
}

Referenced by DosCheckInput(), DosCloseHandle(), DosCopyHandleTable(), DosDeviceIoControl(), DosFlushFileBuffers(), DosGetDevice(), DosReadFile(), DosReadLineBuffered(), and DosWriteFile().

DosLoadDriver()

DWORD DosLoadDriver

(

LPCSTR

DriverFile

)

Definition at line 571 of file device.c.

{
    DWORD Result = ERROR_SUCCESS;
    HANDLE FileHandle = INVALID_HANDLE_VALUE, FileMapping = NULL;
    LPBYTE Address = NULL;
    DWORD Driver;
    PDOS_DRIVER DriverHeader;
    WORD Segment = 0;
    DWORD FileSize;
    DWORD DriversLoaded = 0;
    DOS_INIT_REQUEST Request;
    PDOS_DEVICE_NODE DeviceNode;
 
    /* Open a handle to the driver file */
    FileHandle = CreateFileA(DriverFile,
                             GENERIC_READ,
                             FILE_SHARE_READ,
                             NULL,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);
    if (FileHandle == INVALID_HANDLE_VALUE)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Get the file size */
    FileSize = GetFileSize(FileHandle, NULL);
 
    /* Allocate DOS memory for the driver */
    Segment = DosAllocateMemory(FileSize >> 4, NULL);
    if (Segment == 0)
    {
        Result = Sda->LastErrorCode;
        goto Cleanup;
    }
 
    /* Create a mapping object for the file */
    FileMapping = CreateFileMapping(FileHandle,
                                    NULL,
                                    PAGE_READONLY,
                                    0,
                                    0,
                                    NULL);
    if (FileMapping == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Map the file into memory */
    Address = (LPBYTE)MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 0);
    if (Address == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Copy the entire file to the DOS memory */
    Driver = MAKELONG(0, Segment);
    DriverHeader = (PDOS_DRIVER)FAR_POINTER(Driver);
    RtlCopyMemory(DriverHeader, Address, FileSize);
 
    /* Loop through all the drivers in this file */
    while (TRUE)
    {
        if (!(DriverHeader->DeviceAttributes & DOS_DEVATTR_CHARACTER))
        {
            DPRINT1("Error loading driver at %04X:%04X: "
                    "Block device drivers are not supported.\n",
                    HIWORD(Driver),
                    LOWORD(Driver));
            goto Next;
        }
 
        /* Send the driver an init request */
        RtlZeroMemory(&Request, sizeof(Request));
        Request.Header.RequestLength = sizeof(DOS_INIT_REQUEST);
        Request.Header.CommandCode = DOS_DEVCMD_INIT;
        // TODO: Set Request.DeviceString to the appropriate line in CONFIG.NT!
        DosCallDriver(Driver, &Request.Header);
 
        if (Request.Header.Status & DOS_DEVSTAT_ERROR)
        {
            DPRINT1("Error loading driver at %04X:%04X: "
                    "Initialization routine returned error %u.\n",
                    HIWORD(Driver),
                    LOWORD(Driver),
                    Request.Header.Status & 0x7F);
            goto Next;
        }
 
        /* Create the device node */
        DeviceNode = DosCreateDeviceNode(Driver);
        DeviceNode->IoctlReadRoutine = DosDriverDispatchIoctlRead;
        DeviceNode->ReadRoutine = DosDriverDispatchRead;
        DeviceNode->PeekRoutine = DosDriverDispatchPeek;
        DeviceNode->InputStatusRoutine = DosDriverDispatchInputStatus;
        DeviceNode->FlushInputRoutine = DosDriverDispatchFlushInput;
        DeviceNode->IoctlWriteRoutine = DosDriverDispatchIoctlWrite;
        DeviceNode->WriteRoutine = DosDriverDispatchWrite;
        DeviceNode->OutputStatusRoutine = DosDriverDispatchOutputStatus;
        DeviceNode->FlushOutputRoutine = DosDriverDispatchFlushOutput;
        DeviceNode->OpenRoutine = DosDriverDispatchOpen;
        DeviceNode->CloseRoutine = DosDriverDispatchClose;
        DeviceNode->OutputUntilBusyRoutine = DosDriverDispatchOutputUntilBusy;
 
        DosAddDriver(Driver);
        DriversLoaded++;
 
Next:
        if (LOWORD(DriverHeader->Link) == 0xFFFF) break;
        Driver = DriverHeader->Link;
        DriverHeader = (PDOS_DRIVER)FAR_POINTER(Driver);
    }
 
    DPRINT1("%u drivers loaded from %s.\n", DriversLoaded, DriverFile);
 
Cleanup:
    if (Result != ERROR_SUCCESS)
    {
        /* It was not successful, cleanup the DOS memory */
        if (Segment) DosFreeMemory(Segment);
    }
 
    /* Unmap the file */
    if (Address != NULL) UnmapViewOfFile(Address);
 
    /* Close the file mapping object */
    if (FileMapping != NULL) CloseHandle(FileMapping);
 
    /* Close the file handle */
    if (FileHandle != INVALID_HANDLE_VALUE) CloseHandle(FileHandle);
 
    return Result;
}

DosRemoveDriver()

static VOID DosRemoveDriver ( DWORD  Driver )

static

Definition at line 256 of file device.c.

{
    DWORD CurrentDriver = MAKELONG(DOS_DATA_OFFSET(SysVars.NullDevice), DOS_DATA_SEGMENT);
 
    while (LOWORD(CurrentDriver) != 0xFFFF)
    {
        PDOS_DRIVER DriverHeader = (PDOS_DRIVER)FAR_POINTER(CurrentDriver);
 
        if (DriverHeader->Link == Driver)
        {
            /* Remove it from the list */
            DriverHeader->Link = ((PDOS_DRIVER)FAR_POINTER(DriverHeader->Link))->Link;
            return;
        }
 
        CurrentDriver = DriverHeader->Link;
    }
}

Referenced by DosDeleteDevice().

Variable Documentation

DeviceList

LIST_ENTRY DeviceList = { &DeviceList, &DeviceList }

static

Definition at line 44 of file device.c.

Referenced by DeviceInterruptBop(), DosCreateDeviceNode(), and DosGetDriverNode().

DeviceRequest

PDOS_REQUEST_HEADER DeviceRequest

static

Definition at line 45 of file device.c.

Referenced by DeviceInterruptBop(), and DeviceStrategyBop().

InterruptRoutine

const BYTE InterruptRoutine[]

static

Initial value:

= {
    LOBYTE(EMULATOR_BOP),
    HIBYTE(EMULATOR_BOP),
    BOP_DOS,
    BOP_DRV_INTERRUPT,
    0xCB 
}

Definition at line 34 of file device.c.

Referenced by DosCreateDeviceEx().

StrategyRoutine

const BYTE StrategyRoutine[]

static

Initial value:

= {
    LOBYTE(EMULATOR_BOP),
    HIBYTE(EMULATOR_BOP),
    BOP_DOS,
    BOP_DRV_STRATEGY,
    0xCB 
}

Definition at line 26 of file device.c.

Referenced by DosCreateDeviceEx().