/*++ Copyright (c) 1990 Microsoft Corporation Module Name: ixphwsup.c Abstract: This module contains the HalpXxx routines for the NT I/O system that are hardware dependent. Were these routines not hardware dependent, they would normally reside in the internal.c module. Author: Darryl E. Havens (darrylh) 11-Apr-1990 Environment: Kernel mode, local to I/O system Revision History: --*/ #include "halp.h" #if MCA #include "mca.h" #else #include "eisa.h" #endif #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE,HalpAllocateAdapter) #pragma alloc_text(PAGELK,HalpGrowMapBuffers) #endif // // Some devices require a physically contiguous data buffer for DMA transfers. // Map registers are used to give the appearance that all data buffers are // contiguous. In order to pool all of the map registers a master // adapter object is used. This object is allocated and saved internal to this // file. It contains a bit map for allocation of the registers and a queue // for requests which are waiting for more map registers. This object is // allocated during the first request to allocate an adapter which requires // map registers. // #if defined(_HALPAE_) MASTER_ADAPTER_OBJECT MasterAdapter24; MASTER_ADAPTER_OBJECT MasterAdapter32; #else PADAPTER_OBJECT MasterAdapterObject; #endif BOOLEAN LessThan16Mb; BOOLEAN HalpEisaDma; #define ADAPTER_BASE_MASTER ((PVOID)-1) #if !defined(_HALPAE_) // // Map buffer prameters. These are initialized in HalInitSystem. // PHYSICAL_ADDRESS HalpMapBufferPhysicalAddress; ULONG HalpMapBufferSize; #endif // // Define DMA operations structure. // const DMA_OPERATIONS HalpDmaOperations = { sizeof(DMA_OPERATIONS), (PPUT_DMA_ADAPTER) HalPutDmaAdapter, (PALLOCATE_COMMON_BUFFER) HalAllocateCommonBuffer, (PFREE_COMMON_BUFFER) HalFreeCommonBuffer, (PALLOCATE_ADAPTER_CHANNEL) IoAllocateAdapterChannel, (PFLUSH_ADAPTER_BUFFERS) IoFlushAdapterBuffers, (PFREE_ADAPTER_CHANNEL) IoFreeAdapterChannel, (PFREE_MAP_REGISTERS) IoFreeMapRegisters, (PMAP_TRANSFER) IoMapTransfer, (PGET_DMA_ALIGNMENT) HalGetDmaAlignment, (PREAD_DMA_COUNTER) HalReadDmaCounter, (PGET_SCATTER_GATHER_LIST) HalGetScatterGatherList, (PPUT_SCATTER_GATHER_LIST) HalPutScatterGatherList, (PCALCULATE_SCATTER_GATHER_LIST_SIZE)HalCalculateScatterGatherListSize, (PBUILD_SCATTER_GATHER_LIST) HalBuildScatterGatherList, (PBUILD_MDL_FROM_SCATTER_GATHER_LIST) HalBuildMdlFromScatterGatherList }; BOOLEAN HalpGrowMapBuffers( PADAPTER_OBJECT AdapterObject, ULONG Amount ) /*++ Routine Description: This function attempts to allocate additional map buffers for use by I/O devices. The map register table is updated to indicate the additional buffers. Caller owns the HalpNewAdapter event Arguments: AdapterObject - Supplies the adapter object for which the buffers are to be allocated. Amount - Indicates the size of the map buffers which should be allocated. Return Value: TRUE is returned if the memory could be allocated. FALSE is returned if the memory could not be allocated. --*/ { ULONG MapBufferPhysicalAddress; PVOID MapBufferVirtualAddress; PTRANSLATION_ENTRY TranslationEntry; LONG NumberOfPages; LONG i; PHYSICAL_ADDRESS physicalAddressMinimum; PHYSICAL_ADDRESS physicalAddressMaximum; PHYSICAL_ADDRESS boundaryAddress; KIRQL Irql; PVOID CodeLockHandle; ULONG maximumBufferPages; BOOLEAN dma32Bit; ULONG bytesToAllocate; PAGED_CODE(); dma32Bit = AdapterObject->Dma32BitAddresses; boundaryAddress.QuadPart = 0; NumberOfPages = BYTES_TO_PAGES(Amount); // // Make sure there is room for the additional pages. The maximum number of // slots needed is equal to NumberOfPages + Amount / 64K + 1. // maximumBufferPages = HalpMaximumMapBufferRegisters( dma32Bit ); i = maximumBufferPages - (NumberOfPages + (NumberOfPages * PAGE_SIZE) / 0x10000 + 1 + AdapterObject->NumberOfMapRegisters); if (i < 0) { // // Reduce the allocation amount so it will fit. // NumberOfPages += i; } if (NumberOfPages <= 0) { // // No more memory can be allocated. // return(FALSE); } if (AdapterObject->NumberOfMapRegisters == 0 && HalpMapBufferSize( dma32Bit )) { NumberOfPages = BYTES_TO_PAGES( HalpMapBufferSize( dma32Bit )); // // Since this is the initial allocation, use the buffer allocated by // HalInitSystem rather than allocating a new one. // MapBufferPhysicalAddress = HalpMapBufferPhysicalAddress( dma32Bit ).LowPart; // // Map the buffer for access. // MapBufferVirtualAddress = MmMapIoSpace( HalpMapBufferPhysicalAddress( dma32Bit ), HalpMapBufferSize( dma32Bit ), TRUE // Cache enable. ); if (MapBufferVirtualAddress == NULL) { // // The buffer could not be mapped. // HalpMapBufferSize( dma32Bit ) = 0; return(FALSE); } } else { // // Allocate the map buffers. // physicalAddressMaximum = HalpGetAdapterMaximumPhysicalAddress( AdapterObject ); if (physicalAddressMaximum.LowPart == (ULONG)-1) { // // This adapter can handle at least 32-bit addresses. In an effort // to leave memory to 24-bit adapters, try to make this allocation // above the 24 bit line. // physicalAddressMinimum.QuadPart = MAXIMUM_PHYSICAL_ADDRESS; } else { physicalAddressMinimum.QuadPart = 0; } bytesToAllocate = NumberOfPages * PAGE_SIZE; // // This loop is executed a maximum of two times. // while(TRUE) { MapBufferVirtualAddress = MmAllocateContiguousMemorySpecifyCache( bytesToAllocate, physicalAddressMinimum, physicalAddressMaximum, boundaryAddress, MmCached ); if (MapBufferVirtualAddress != NULL) { // // The memory was allocated. // break; } // // The allocation attempt failed. // if (physicalAddressMinimum.QuadPart != 0) { // // We were trying to allocate memory above the 16M line as // an optimization. Relax that requirement and try again. // physicalAddressMinimum.QuadPart = 0; } else { // // The memory could not be allocated. // return FALSE; } } // // Get the physical address of the map base. // MapBufferPhysicalAddress = MmGetPhysicalAddress( MapBufferVirtualAddress ).LowPart; } // // Initialize the map registers where memory has been allocated. // Serialize with master adapter object. // CodeLockHandle = MmLockPagableCodeSection (&HalpGrowMapBuffers); KeAcquireSpinLock( &AdapterObject->SpinLock, &Irql ); TranslationEntry = ((PTRANSLATION_ENTRY) AdapterObject->MapRegisterBase) + AdapterObject->NumberOfMapRegisters; for (i = 0; (LONG) i < NumberOfPages; i++) { // // Make sure the perivous entry is physically contiguous with the next // entry and that a 64K physical bountry is not crossed unless this // is an Eisa system. // if (TranslationEntry != AdapterObject->MapRegisterBase && (((TranslationEntry - 1)->PhysicalAddress + PAGE_SIZE) != MapBufferPhysicalAddress || (!HalpEisaDma && ((TranslationEntry - 1)->PhysicalAddress & ~0x0ffff) != (MapBufferPhysicalAddress & ~0x0ffff)))) { // // An entry needs to be skipped in the table. This entry will // remain marked as allocated so that no allocation of map // registers will cross this bountry. // TranslationEntry++; AdapterObject->NumberOfMapRegisters++; } // // Clear the bits where the memory has been allocated. // RtlClearBits( AdapterObject->MapRegisters, (ULONG)(TranslationEntry - (PTRANSLATION_ENTRY) AdapterObject->MapRegisterBase), 1 ); TranslationEntry->VirtualAddress = MapBufferVirtualAddress; TranslationEntry->PhysicalAddress = MapBufferPhysicalAddress; TranslationEntry++; (PCCHAR) MapBufferVirtualAddress += PAGE_SIZE; MapBufferPhysicalAddress += PAGE_SIZE; } // // Remember the number of pages that were allocated. // AdapterObject->NumberOfMapRegisters += NumberOfPages; // // Release master adapter object. // KeReleaseSpinLock( &AdapterObject->SpinLock, Irql ); MmUnlockPagableImageSection (CodeLockHandle); return(TRUE); } #if defined(HalpAllocateAdapterEx) #undef HalpAllocateAdapterEx #endif PADAPTER_OBJECT HalpAllocateAdapterEx( IN ULONG MapRegistersPerChannel, IN PVOID AdapterBaseVa, IN PVOID ChannelNumber, IN BOOLEAN Dma32Bit ) /*++ Routine Description: This routine allocates and initializes an adapter object to represent an adapter or a DMA controller on the system. If no map registers are required then a standalone adapter object is allocated with no master adapter. If map registers are required, then a master adapter object is used to allocate the map registers. For Isa systems these registers are really physically contiguous memory pages. Caller owns the HalpNewAdapter event Arguments: MapRegistersPerChannel - Specifies the number of map registers that each channel provides for I/O memory mapping. AdapterBaseVa - Address of the the DMA controller or ADAPTER_BASE_MASTER. ChannelNumber - Unused. Dma32Bit - Indicates whether the adapter is 24 bit or 32 bit. Return Value: The function value is a pointer to the allocate adapter object. --*/ { PADAPTER_OBJECT AdapterObject; OBJECT_ATTRIBUTES ObjectAttributes; ULONG Size; ULONG BitmapSize; HANDLE Handle; NTSTATUS Status; ULONG mapBuffers; BOOLEAN creatingMaster; UNREFERENCED_PARAMETER(ChannelNumber); PAGED_CODE(); if (AdapterBaseVa == ADAPTER_BASE_MASTER) { creatingMaster = TRUE; } else { creatingMaster = FALSE; } // // Initialize the master adapter if necessary. // if (creatingMaster == FALSE && MapRegistersPerChannel != 0) { // // This is not a recursive master adapter allocation, and map registers // are necessary. Allocate a master adapter object of the appropriate // type if necessary. // if (HalpMasterAdapter( Dma32Bit ) == NULL) { AdapterObject = HalpAllocateAdapterEx( MapRegistersPerChannel, ADAPTER_BASE_MASTER, NULL, Dma32Bit ); // // If we could not allocate the master adapter then give up. // if (AdapterObject == NULL) { return NULL; } AdapterObject->Dma32BitAddresses = Dma32Bit; AdapterObject->MasterDevice = Dma32Bit; HalpMasterAdapter( Dma32Bit ) = AdapterObject; } } // // Begin by initializing the object attributes structure to be used when // creating the adapter object. // InitializeObjectAttributes( &ObjectAttributes, NULL, OBJ_PERMANENT, (HANDLE) NULL, (PSECURITY_DESCRIPTOR) NULL ); // // Determine the size of the adapter object. If this is the master object // then allocate space for the register bit map; otherwise, just allocate // an adapter object. // if (creatingMaster != FALSE) { // // Allocate a bit map large enough MAXIMUM_MAP_BUFFER_SIZE / PAGE_SIZE // of map register buffers. // mapBuffers = HalpMaximumMapBufferRegisters( Dma32Bit ); BitmapSize = (((sizeof( RTL_BITMAP ) + ((mapBuffers + 7) >> 3)) + 3) & ~3); Size = sizeof( ADAPTER_OBJECT ) + BitmapSize; } else { Size = sizeof( ADAPTER_OBJECT ); } // // Now create the adapter object. // Status = ObCreateObject( KernelMode, *IoAdapterObjectType, &ObjectAttributes, KernelMode, (PVOID) NULL, Size, 0, 0, (PVOID *)&AdapterObject ); // // Reference the object. // if (NT_SUCCESS(Status)) { Status = ObReferenceObjectByPointer( AdapterObject, FILE_READ_DATA | FILE_WRITE_DATA, *IoAdapterObjectType, KernelMode ); } // // If the adapter object was successfully created, then attempt to insert // it into the object table. // if (NT_SUCCESS( Status )) { RtlZeroMemory (AdapterObject, sizeof (ADAPTER_OBJECT)); Status = ObInsertObject( AdapterObject, NULL, FILE_READ_DATA | FILE_WRITE_DATA, 0, (PVOID *) NULL, &Handle ); if (NT_SUCCESS( Status )) { ZwClose( Handle ); // // Initialize the adapter object itself. // AdapterObject->DmaHeader.Version = IO_TYPE_ADAPTER; AdapterObject->DmaHeader.Size = (USHORT) Size; AdapterObject->MapRegistersPerChannel = 1; AdapterObject->AdapterBaseVa = AdapterBaseVa; AdapterObject->ChannelNumber = 0xff; AdapterObject->DmaHeader.DmaOperations = (PDMA_OPERATIONS)&HalpDmaOperations; AdapterObject->Dma32BitAddresses = Dma32Bit; if (MapRegistersPerChannel) { AdapterObject->MasterAdapter = HalpMasterAdapter( Dma32Bit ); } else { AdapterObject->MasterAdapter = NULL; } // // Initialize the channel wait queue for this adapter. // KeInitializeDeviceQueue( &AdapterObject->ChannelWaitQueue ); // // If this is the MasterAdatper then initialize the register bit map, // AdapterQueue and the spin lock. // if (creatingMaster != FALSE) { KeInitializeSpinLock( &AdapterObject->SpinLock ); InitializeListHead( &AdapterObject->AdapterQueue ); AdapterObject->MapRegisters = (PVOID) ( AdapterObject + 1); RtlInitializeBitMap( AdapterObject->MapRegisters, (PULONG) (((PCHAR) (AdapterObject->MapRegisters)) + sizeof( RTL_BITMAP )), ( mapBuffers ) ); // // Set all the bits in the memory to indicate that memory // has not been allocated for the map buffers. // RtlSetAllBits( AdapterObject->MapRegisters ); AdapterObject->NumberOfMapRegisters = 0; AdapterObject->CommittedMapRegisters = 0; // // Allocate the memory map registers. // AdapterObject->MapRegisterBase = ExAllocatePoolWithTag( NonPagedPool, mapBuffers * sizeof(TRANSLATION_ENTRY), HAL_POOL_TAG ); if (AdapterObject->MapRegisterBase == NULL) { ObDereferenceObject( AdapterObject ); AdapterObject = NULL; return(NULL); } // // Zero the map registers. // RtlZeroMemory( AdapterObject->MapRegisterBase, mapBuffers * sizeof(TRANSLATION_ENTRY) ); if (!HalpGrowMapBuffers(AdapterObject, INITIAL_MAP_BUFFER_SMALL_SIZE)) { // // If no map registers could be allocated then free the // object. // ObDereferenceObject( AdapterObject ); AdapterObject = NULL; return(NULL); } } } else { // // An error was incurred for some reason. Set the return value // to NULL. // AdapterObject = (PADAPTER_OBJECT) NULL; } } else { AdapterObject = (PADAPTER_OBJECT) NULL; } return AdapterObject; } PADAPTER_OBJECT HalpAllocateAdapter( IN ULONG MapRegistersPerChannel, IN PVOID AdapterBaseVa, IN PVOID ChannelNumber ) /*++ Routine Description: This routine allocates and initializes an adapter object to represent an adapter or a DMA controller on the system. If no map registers are required then a standalone adapter object is allocated with no master adapter. If map registers are required, then a master adapter object is used to allocate the map registers. For Isa systems these registers are really physically contiguous memory pages. Caller owns the HalpNewAdapter event Arguments: MapRegistersPerChannel - Specifies the number of map registers that each channel provides for I/O memory mapping. AdapterBaseVa - Address of the DMA controller or ADAPTER_BASE_MASTER. ChannelNumber - Unused. Return Value: The function value is a pointer to the allocate adapter object. --*/ { return HalpAllocateAdapterEx( MapRegistersPerChannel, AdapterBaseVa, ChannelNumber, FALSE ); } ULONG HalGetDmaAlignment ( PVOID Conext ) { return HalGetDmaAlignmentRequirement(); }