NTSTATUS
PLxInitializeDMA(
IN PDEVICE_EXTENSION DevExt
)
/*++
Routine Description:
Initializes the DMA adapter.
Arguments:
DevExt Pointer to our DEVICE_EXTENSION
Return Value:
None
--*/
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
PAGED_CODE();
//
// PLx PCI9656 DMA_TRANSFER_ELEMENTS must be 16-byte aligned
//
WdfDeviceSetAlignmentRequirement( DevExt->Device,
PCI9656_DTE_ALIGNMENT_16 );
//
// Create a new DMA Enabler instance.
// Use Scatter/Gather, 64-bit Addresses, Duplex-type profile.
//
{
WDF_DMA_ENABLER_CONFIG dmaConfig;
WDF_DMA_ENABLER_CONFIG_INIT( &dmaConfig,
WdfDmaProfileScatterGather64Duplex,
DevExt->MaximumTransferLength );
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
" - The DMA Profile is WdfDmaProfileScatterGather64Duplex");
status = WdfDmaEnablerCreate( DevExt->Device,
&dmaConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&DevExt->DmaEnabler );
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDmaEnablerCreate failed: %!STATUS!", status);
return status;
}
}
//
// Allocate common buffer for building writes
//
// NOTE: This common buffer will not be cached.
// Perhaps in some future revision, cached option could
// be used. This would have faster access, but requires
// flushing before starting the DMA in PLxStartWriteDma.
//
DevExt->WriteCommonBufferSize =
sizeof(DMA_TRANSFER_ELEMENT) * DevExt->WriteTransferElements;
_Analysis_assume_(DevExt->WriteCommonBufferSize > 0);
status = WdfCommonBufferCreate( DevExt->DmaEnabler,
DevExt->WriteCommonBufferSize,
WDF_NO_OBJECT_ATTRIBUTES,
&DevExt->WriteCommonBuffer );
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfCommonBufferCreate (write) failed: %!STATUS!", status);
return status;
}
DevExt->WriteCommonBufferBase =
WdfCommonBufferGetAlignedVirtualAddress(DevExt->WriteCommonBuffer);
DevExt->WriteCommonBufferBaseLA =
WdfCommonBufferGetAlignedLogicalAddress(DevExt->WriteCommonBuffer);
RtlZeroMemory( DevExt->WriteCommonBufferBase,
DevExt->WriteCommonBufferSize);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"WriteCommonBuffer 0x%p (#0x%I64X), length %I64d",
DevExt->WriteCommonBufferBase,
DevExt->WriteCommonBufferBaseLA.QuadPart,
WdfCommonBufferGetLength(DevExt->WriteCommonBuffer) );
//
// Allocate common buffer for building reads
//
// NOTE: This common buffer will not be cached.
// Perhaps in some future revision, cached option could
// be used. This would have faster access, but requires
// flushing before starting the DMA in PLxStartReadDma.
//
DevExt->ReadCommonBufferSize =
sizeof(DMA_TRANSFER_ELEMENT) * DevExt->ReadTransferElements;
_Analysis_assume_(DevExt->ReadCommonBufferSize > 0);
status = WdfCommonBufferCreate( DevExt->DmaEnabler,
DevExt->ReadCommonBufferSize,
WDF_NO_OBJECT_ATTRIBUTES,
&DevExt->ReadCommonBuffer );
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfCommonBufferCreate (read) failed %!STATUS!", status);
return status;
}
DevExt->ReadCommonBufferBase =
WdfCommonBufferGetAlignedVirtualAddress(DevExt->ReadCommonBuffer);
DevExt->ReadCommonBufferBaseLA =
WdfCommonBufferGetAlignedLogicalAddress(DevExt->ReadCommonBuffer);
RtlZeroMemory( DevExt->ReadCommonBufferBase,
DevExt->ReadCommonBufferSize);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"ReadCommonBuffer 0x%p (#0x%I64X), length %I64d",
DevExt->ReadCommonBufferBase,
DevExt->ReadCommonBufferBaseLA.QuadPart,
WdfCommonBufferGetLength(DevExt->ReadCommonBuffer) );
//
// Since we are using sequential queue and processing one request
// at a time, we will create transaction objects upfront and reuse
// them to do DMA transfer. Transactions objects are parented to
// DMA enabler object by default. They will be deleted along with
// along with the DMA enabler object. So need to delete them
// explicitly.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, TRANSACTION_CONTEXT);
status = WdfDmaTransactionCreate( DevExt->DmaEnabler,
&attributes,
&DevExt->ReadDmaTransaction);
if(!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_WRITE,
"WdfDmaTransactionCreate(read) failed: %!STATUS!", status);
return status;
}
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, TRANSACTION_CONTEXT);
//
// Create a new DmaTransaction.
//
status = WdfDmaTransactionCreate( DevExt->DmaEnabler,
&attributes,
&DevExt->WriteDmaTransaction );
if(!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_WRITE,
"WdfDmaTransactionCreate(write) failed: %!STATUS!", status);
return status;
}
return status;
}
NTSTATUS
AmccPciAddDevice(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
EvtDeviceAdd is called by the framework in response to AddDevice
call from the PnP manager. It is responsible for initializing and
creating a WDFDEVICE object.
Any work that should be done after the object is created should be
deferred until EvtDeviceSoftwareInit, as that callback will be made
with the device lock held (if there is one.)
Arguments:
Driver - Handle to a framework driver object created in DriverEntry
DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
Return Value:
NTSTATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fdoAttributes;
WDF_INTERRUPT_CONFIG interruptConfig;
WDF_OBJECT_ATTRIBUTES interruptAttributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
PAMCC_DEVICE_EXTENSION devExt;
WDFQUEUE hQueue;
WDFDEVICE device;
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"AmccPciAddDevice: 0x%p", Driver);
//
// Zero out the PnpPowerCallbacks structure.
//
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// Set Callbacks for any of the functions we are interested in.
// If no callback is set, Framework will take the default action
// by itself.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = AmccPciEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = AmccPciEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = AmccPciEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = AmccPciEvtDeviceD0Exit;
//
// Register the PnP Callbacks..
//
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
//
// Set various attributes for this device
//
WdfDeviceInitSetIoType( DeviceInit, WdfDeviceIoDirect );
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&fdoAttributes, AMCC_DEVICE_EXTENSION);
fdoAttributes.EvtCleanupCallback = AmccPciContextCleanup;
//
// We want all the queue callbacks, cancel routine, and DpcForIsr to be serialized
// at the device level, so we don't have worry about any synchronization issues.
//
fdoAttributes.SynchronizationScope = WdfSynchronizationScopeDevice;
status = WdfDeviceCreate( &DeviceInit, &fdoAttributes, &device );
if ( !NT_SUCCESS(status) ) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfDeviceInitialize failed 0x%X", status);
return status;
}
//
// Device Initialization is complete.
// Get the Device Extension and initialize it.
//
devExt = AmccPciGetDevExt(device);
devExt->Device = device;
TraceEvents(TRACE_LEVEL_INFORMATION, AMCC_TRACE_INIT,
"PDO 0x%p, FDO 0x%p, DevExt 0x%p",
WdfDeviceWdmGetPhysicalDevice(device),
WdfDeviceWdmGetDeviceObject( device ), devExt);
//
// This device generates an interrupt. So create an interrupt object which
// will later be associated with the devices resources and connected
// by the Framework.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&interruptAttributes, INTERRUPT_DATA);
//
// Configure the Interrupt object
//
WDF_INTERRUPT_CONFIG_INIT(&interruptConfig,
AmccPciEvtInterruptIsr,
AmccPciEvtInterruptDpc);
status = WdfInterruptCreate(device,
&interruptConfig,
&interruptAttributes,
&devExt->WdfInterrupt);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfInterruptCreate failed: %!STATUS!\n", status);
return status;
}
//
// The S5933 requires DMA buffers be aligned on a 32-bit boundary
//
// NOTE: Read the existing alignment value. If it is greater than
// or equal then keep it. If it is less then update the
// alignment requirement field with this device's required
// value.
//
// NOTE: See the MSDN section titled "Initializing a Device Object"
// for details on how to specify this alignment value.
//
// NOTE: AMCC5933_ALIGNMENT__32BITS is equated to (4-1) for 32-bit
// alignment.
//
{
ULONG alignReq;
alignReq = WdfDeviceGetAlignmentRequirement( device );
if (alignReq < AMCC5933_ALIGNMENT__32BITS) {
//
// Set the S5933 alignment requirement as new value.
//
WdfDeviceSetAlignmentRequirement( device,
AMCC5933_ALIGNMENT__32BITS);
}
}
//
// Register I/O callbacks.
//
// Create a sequential IO Queue for serial operation. That means all the requests (Read/Write
// & IOCTL) are serialized to the device. Until the driver completes the request presented to it,
// the framework will not schedule another one. The requests held in the framework will be
// cancelled automatically if the source of request (application) terminate or cancels it.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE( &ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoDefault = AmccPciEvtIoDefault;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests for
// long time or forward them to other drivers.
// If the EvtIoStop callback is not implemented, the framework waits for
// all driver-owned requests to be done before moving in the Dx/sleep
// states or before removing the device, which is the correct behavior
// for this type of driver. If the requests were taking an indeterminate
// amount of time to complete, or if the driver forwarded the requests
// to a lower driver/another stack, the queue should have an
// EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate( device,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&hQueue );
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS (status)) {
//
// We don't have worry about deleting the device here because framework will automatically
// cleanup that when the driver unloads.
//
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"WdfIoQueueCreate failed %!STATUS!", status);
return status;
}
//
// Register an interface so that application can find and talk to us.
// NOTE: See the note in Public.h concerning this GUID value.
//
status = WdfDeviceCreateDeviceInterface( device,
(LPGUID) &GUID_DEVINTERFACE_AMCC_PCI,
NULL );
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, AMCC_TRACE_INIT,
"<-- AMCCAddDevice: WdfDeviceCreateDeviceInterface failed %!STATUS!", status);
return status;
}
devExt->MaximumTransferLength = MAXIMUM_REQUEST_CONTEXT_LENGTH;
//
// Set the maximum physical pages for now, but this value may change if
// there aren't enough map registers
//
devExt->MaximumPhysicalPages = MAXIMUM_PHYSICAL_PAGES;
return status;
}
NTSTATUS
UfxClientDeviceCreate(
_In_ WDFDRIVER Driver,
_In_ PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Worker routine called to create a device and its software resources.
Arguments:
Driver - WDF driver object
DeviceInit - Pointer to an opaque init structure. Memory for this
structure will be freed by the framework when the WdfDeviceCreate
succeeds. So don't access the structure after that point.
Return Value:
Appropriate NTSTATUS value
--*/
{
WDF_OBJECT_ATTRIBUTES DeviceAttributes;
WDFDEVICE WdfDevice;
NTSTATUS Status;
WDF_PNPPOWER_EVENT_CALLBACKS PnpCallbacks;
WDF_DMA_ENABLER_CONFIG DmaConfig;
PCONTROLLER_CONTEXT ControllerContext;
PAGED_CODE();
TraceEntry();
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&DeviceAttributes, CONTROLLER_CONTEXT);
//
// Do UFX-specific initialization
//
Status = UfxFdoInit(Driver, DeviceInit, &DeviceAttributes);
CHK_NT_MSG(Status, "Failed UFX initialization");
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpCallbacks);
PnpCallbacks.EvtDevicePrepareHardware = OnEvtDevicePrepareHardware;
PnpCallbacks.EvtDeviceReleaseHardware = OnEvtDeviceReleaseHardware;
PnpCallbacks.EvtDeviceD0Entry = OnEvtDeviceD0Entry;
PnpCallbacks.EvtDeviceD0Exit = OnEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &PnpCallbacks);
Status = WdfDeviceCreate(&DeviceInit, &DeviceAttributes, &WdfDevice);
CHK_NT_MSG(Status, "Failed to create wdf device");
ControllerContext = DeviceGetControllerContext(WdfDevice);
KeInitializeEvent(&ControllerContext->DetachEvent,
NotificationEvent,
FALSE);
WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT(&ControllerContext->IdleSettings, IdleCanWakeFromS0);
ControllerContext->IdleSettings.IdleTimeoutType = SystemManagedIdleTimeoutWithHint;
ControllerContext->IdleSettings.IdleTimeout = IDLE_TIMEOUT;
ControllerContext->IdleSettings.DxState = PowerDeviceD3;
Status = WdfDeviceAssignS0IdleSettings(WdfDevice, &ControllerContext->IdleSettings);
LOG_NT_MSG(Status, "Failed to set S0 Idle Settings");
//
// Create and initialize device's default queue
//
Status = DefaultQueueCreate(WdfDevice);
CHK_NT_MSG(Status, "Failed to intialize default queue");
//
// Set alignment required by controller
//
WdfDeviceSetAlignmentRequirement(WdfDevice, UFX_CLIENT_ALIGNMENT);
//
// Create and Initialize DMA Enabler object for the device.
//
WDF_DMA_ENABLER_CONFIG_INIT(
&DmaConfig,
WdfDmaProfileScatterGatherDuplex,
MAX_DMA_LENGTH);
//
// Version 3 is required to perform multiple
// simultaneous transfers.
//
DmaConfig.WdmDmaVersionOverride = 3;
Status = WdfDmaEnablerCreate(
WdfDevice,
&DmaConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&ControllerContext->DmaEnabler);
CHK_NT_MSG(Status, "Failed to create DMA enabler object");
//
// Create UFXDEVICE object
//
Status = UfxDevice_DeviceCreate(WdfDevice);
CHK_NT_MSG(Status, "Failed to create UFX Device object");
//
// Create DPC Lock
//
Status = WdfSpinLockCreate(WDF_NO_OBJECT_ATTRIBUTES, &ControllerContext->DpcLock);
CHK_NT_MSG(Status, "Failed to create DPC lock");
Status = WdfWaitLockCreate(WDF_NO_OBJECT_ATTRIBUTES, &ControllerContext->InitializeDefaultEndpointLock);
CHK_NT_MSG(Status, "Failed to create Ep0 init lock");
End:
TraceExit();
return Status;
}
