|
|
//---------------------------------------------------------------------------
//
// Module: device.c
//
// Description:
//
//
//@@BEGIN_MSINTERNAL
// Development Team:
// S.Mohanraj
// M.McLaughlin
//
// History: Date Author Comment
//
//@@END_MSINTERNAL
//---------------------------------------------------------------------------
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// Copyright (c) 1995 Microsoft Corporation. All Rights Reserved.
//
//---------------------------------------------------------------------------
#define IRPMJFUNCDESC
//#define MAX_DEBUG 1
#include "common.h"
#ifndef UNDER_NT
#include <ntddk.h>
#include <windef.h>
#pragma warning( disable : 4273 )
#include "..\..\..\..\dos\dos386\vxd\ntkern\inc\rtl.h"
#pragma warning( default : 4273 )
#include "..\..\..\..\dos\dos386\vxd\ntkern\hal\ixisa.h"
#else
#include <nthal.h>
// NOTE! In order to remove cross depot include file dependencies.
// Which break peoples builds if they try to build drivers when they are
// not enlisted in base, I have made a local copy of the file
// base\hals\halx86\i386\ixisa.h. That is the file that defines the
// real ADAPTER_OBJECT structure. This local copy should be kept in sync
// with the original.
#include "ixisa.h"
#endif
#include <rt.h>
#include "glitch.h"
// Maximum number of times we will retry allocating memory for aliasing
// DMA buffers.
#define MAX_RESERVE_RETRIES 128
#ifndef UNDER_NT
#include <vmm.h>
ULONG __stdcall GLITCH_Init_VxD(VOID);
#else
PDEVICE_OBJECT pDO;
#endif
PVOID MapPhysicalToLinear(VOID *physicaladdress, ULONG numbytes, ULONG flags);ULONG GetCR3(VOID);
VOID DriverUnload( IN PDRIVER_OBJECT DriverObject){ //dprintf((" DriverUnload Enter (DriverObject = %x)", DriverObject));
Break();
}
NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING usRegistryPathName){
#ifdef UNDER_NT
UNICODE_STRING usDeviceName; UNICODE_STRING usLinkName; PHYSICAL_ADDRESS Physical;#endif
ADAPTER_OBJECT *DmaControllerObject, *MasterAdapter; DEVICE_DESCRIPTION DmaDevice={0}; ULONG MapRegisterCount; ULONG i; PVOID BadReserve[MAX_RESERVE_RETRIES]; ULONG BadReserveCount=0; NTSTATUS Status = STATUS_SUCCESS;
#ifdef UNDER_NT
DriverObject->MajorFunction[IRP_MJ_CREATE] = DeviceIoCreate; DriverObject->MajorFunction[IRP_MJ_CLOSE] = DeviceIoClose; DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceIoControl;#endif
DriverObject->DriverUnload = DriverUnload;
// For now, keep the driver loaded always.
ObReferenceObject(DriverObject);
#ifndef UNDER_NT
GLITCH_Init_VxD();
#else
RtlInitUnicodeString( &usDeviceName, STR_DEVICENAME );
Status = IoCreateDevice( DriverObject, 0, &usDeviceName, FILE_DEVICE_SOUND, 0, FALSE, &pDO );
if (!NT_SUCCESS(Status)) { return Status; }
RtlInitUnicodeString( &usLinkName, STR_LINKNAME );
Status = IoCreateSymbolicLink( &usLinkName, &usDeviceName );
if(!NT_SUCCESS(Status)) { IoDeleteDevice( pDO ); return Status; }
#endif
// Now allocate the buffer for writing glitch information.
// Note that we actually allocate space for the GlitchInfo structure here
// as well. We allocate space for the output buffer plus 1 page for
// the GlitchInfo structure. This is so that they are tied together
// and we can map both back to user mode at the same time. It is
// also because it makes it easy for the user mode code to build its
// own pointer to the actual output buffer from the pointer it
// gets to the GlitchInfo structure. It is important that the
// user mode code be able to do that easily because the pointer
// that we put in the GlitchInfo structure is for our own kernel mode
// use only. It cannot be used by the user mode code - since the
// buffer will be mapped to a completely different virtual address
// for the user mode code anyway.
#ifdef UNDER_NT
Physical.QuadPart=-1I64;GlitchInfo=(PGLITCHDATA)MmAllocateContiguousMemory(PROCPAGESIZE*(4+1), Physical);#else
GlitchInfo=(PGLITCHDATA)ExAllocatePool(NonPagedPool, PROCPAGESIZE*(4+1));#endif
if (GlitchInfo==NULL) { Status=STATUS_NO_MEMORY;#ifdef UNDER_NT
IoDeleteSymbolicLink( &usLinkName ); IoDeleteDevice( pDO );#endif
return Status; }
GlitchInfo->WriteLocation=0;GlitchInfo->ReadLocation=0;
// The output or print buffersize MUST be a power of 2. This is because the read and write
// locations increment constantly and DO NOT WRAP with the buffer size. That is intentional
// because it makes checking whether there is data in the buffer or not very simple and atomic.
// However, the read and write locations will wrap on 32 bit boundaries. This is OK as long as
// our buffersize divides into 2^32 evenly, which it always will if it is a power of 2.
GlitchInfo->BufferSize=PROCPAGESIZE*4;
GlitchInfo->pBuffer=(PCHAR)GlitchInfo+PROCPAGESIZE;
// Mark every slot in the output buffer empty.
for (i=0; i<GlitchInfo->BufferSize; i+=PACKETSIZE) { ((ULONG *)GlitchInfo->pBuffer)[i/sizeof(ULONG)]=NODATA; }
DmaDevice.Version=DEVICE_DESCRIPTION_VERSION1;DmaDevice.Master=FALSE;DmaDevice.ScatterGather=FALSE;DmaDevice.DemandMode=FALSE;DmaDevice.AutoInitialize=TRUE;DmaDevice.Dma32BitAddresses=TRUE;DmaDevice.IgnoreCount=FALSE;DmaDevice.Reserved1=FALSE;DmaDevice.DmaChannel=0;DmaDevice.InterfaceType=Internal; // Internal, ISA, EISA
DmaDevice.DmaWidth=Width8Bits; // Width8Bits, Width16Bits, or Width32Bits
DmaDevice.DmaSpeed=Compatible; // Compatible, TypeA, TypeB, or TypeC
DmaDevice.MaximumLength=1<<12;DmaDevice.DmaPort=0;
MapRegisterCount=1;
DmaControllerObject=(ADAPTER_OBJECT *)HalGetAdapter(&DmaDevice, &MapRegisterCount);
MasterAdapter=DmaControllerObject->MasterAdapter;
for (i=0; i<8; i++) {
if (i==2 || i==4) { continue; }
if (MasterAdapter->AdapterBaseVa==(PVOID)(-1I64)) {
PDMAINFO ChannelInfo;
// First allocate space for tracking this channel.
ChannelInfo=(PDMAINFO)ExAllocatePool(NonPagedPool, sizeof(DMAINFO));
if (ChannelInfo==NULL) { Status=STATUS_NO_MEMORY; break; }
// Fill in information about this channel.
ChannelInfo->Channel=i; ChannelInfo->pMasterAdapterSpinLock=&MasterAdapter->SpinLock; ChannelInfo->Read32BitPhysicalAddresses=MasterAdapter->Dma32BitAddresses;
// Now get CR3 and map the page directory. This enables us to remap
// the physical pages inside our RT thread. So, we can map our pDmaBuffer
// to whatever physical addresses the hardware DMA buffer is mapped to.
ChannelInfo->CR3=GetCR3(); ChannelInfo->PageDirectory=(PULONG)MapPhysicalToLinear((PVOID)ChannelInfo->CR3, PROCPAGESIZE, 0);
// Now get a set of linear pages that we can remap to whereever we need.
// Make SURE that this set of linear pages all share a single page directory entry.
// To do this we use a very simple algorithm. If any of the allocations we
// make happens to cross a page directory entry (4MB boundary) then simply
// save the location of the bad allocation, and make another allocation.
// We will free all of the bad allocations after we have processed all of the
// channels. That way we hold onto all the bad allocations until after we have
// finish getting a full set of acceptable allocations.
#ifdef UNDER_NT
#define PR_SYSTEM 0
#define PR_FIXED 0
#endif
ChannelInfo->pDmaBuffer=NULL; while (ChannelInfo->pDmaBuffer==NULL && BadReserveCount<MAX_RESERVE_RETRIES) { ChannelInfo->pDmaBuffer=ReservePages(PR_SYSTEM, PAGECOUNT, PR_FIXED); // Does this set of pages cross a 4MB boundary?
if (((ULONG_PTR)ChannelInfo->pDmaBuffer^((ULONG_PTR)ChannelInfo->pDmaBuffer+PAGECOUNT*PROCPAGESIZE))&(4*1024*1024)) { // This set of pages crosses page directory entries. Dump it and retry.
BadReserve[BadReserveCount++]=ChannelInfo->pDmaBuffer; ChannelInfo->pDmaBuffer=NULL; } }
if (ChannelInfo->pDmaBuffer==NULL) { Status=STATUS_NO_MEMORY; break; }
// Now get a linear address for the page table containing this set of reserved pages.
// I need that so I can change the page table entries and map the pages directly.
ChannelInfo->PageTable=MapPhysicalToLinear((PVOID)((ChannelInfo->PageDirectory[(ULONG)(ChannelInfo->pDmaBuffer)>>22])&(~(PROCPAGESIZE-1))), PROCPAGESIZE, 0);
// Now lock down my linear address alias of my page.
//LockPages((ULONG)ChannelInfo->PageTable, 1, 0, 0);
// This fails. The function returns zero, it has to be non zero for success.
ChannelInfo->DmaBufferSize=0; ChannelInfo->PhysicalDmaBufferStart=0;
ChannelInfo->pPrintBuffer=GlitchInfo->pBuffer; ChannelInfo->PrintBufferSize=GlitchInfo->BufferSize; ChannelInfo->pPrintLoad=&GlitchInfo->WriteLocation; ChannelInfo->pPrintEmpty=&GlitchInfo->ReadLocation;
// Create the realtime glitch detection thread.
Status=RtCreateThread(1*MSEC, 50*USEC, 0, 2, GlitchDetect, (PVOID)ChannelInfo, NULL);
if (!NT_SUCCESS(Status)) { // Free the ChannelInfo we allocated for this realtime thread.
ExFreePool(ChannelInfo); // Stop trying to create additional realtime threads.
break; }
} else { Trap(); Status=STATUS_UNSUCCESSFUL; break; }
}
// Now clean up properly if we failed during creation of the glitch monitor
// realtime threads.
// Note that we only free up allocated resources if NO realtime threads were
// successfully created. If we successfully created ANY realtime threads,
// then do not shut them down, and return STATUS_SUCCESS.
if (!NT_SUCCESS(Status) && i==0) {
#ifdef UNDER_NT
MmFreeContiguousMemory(GlitchInfo); IoDeleteSymbolicLink( &usLinkName ); IoDeleteDevice( pDO );
#else
ExFreePool(GlitchInfo);
#endif
} else {
#ifdef UNDER_NT
pDO->Flags |= DO_DIRECT_IO ; pDO->Flags &= ~DO_DEVICE_INITIALIZING;
#endif
Status=STATUS_SUCCESS; // We MUST do this in case Status is an error, but i!=0.
}
// Now clean up any bad reserves before we leave.
// Note that we do this here instead of before the above if statement, so that
// we can reuse i without screwing up the i=0 check in the if statement.
for (i=0; i<BadReserveCount; i++) { FreePages(BadReserve[i], 0); }
DbgPrint("Glitch.sys allocated %d DMA alias buffers that crossed 4MB boundaries.\n", BadReserveCount);
return Status;
}
|
