//
// Internal Function: UartCtlImmediateChar
//
VOID
UartCtlImmediateChar(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
UNREFERENCED_PARAMETER(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
//
// Interleaving an immediate character into the write path
// has not been implemented in this sample.
//
status = STATUS_NOT_IMPLEMENTED;
TraceMessage(TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
UartEvaluateLineStatus(
_In_ WDFDEVICE Device,
_Out_ PBOOLEAN CanReceive,
_Out_ PBOOLEAN CanTransmit,
_Out_ PBOOLEAN HasErrors
)
{
UCHAR regLineStatus = 0;
UCHAR oldErrorBits = 0;
PUART_DEVICE_EXTENSION pDevExt = NULL;
FuncEntry(TRACE_FLAG_REGUTIL);
pDevExt = UartGetDeviceExtension(Device);
regLineStatus = READ_LINE_STATUS(pDevExt, pDevExt->Controller);
if (pDevExt->LineStatus != regLineStatus)
{
// LSR changed.
// If there is an error indicated, binary OR it with the previous error.
oldErrorBits = pDevExt->LineStatus & SERIAL_LSR_ERROR;
pDevExt->LineStatus = regLineStatus | oldErrorBits;
}
pDevExt->HoldingEmpty = ((pDevExt->LineStatus & SERIAL_LSR_THRE) != 0);
*CanReceive = ((pDevExt->LineStatus & SERIAL_LSR_DR) != 0);
*CanTransmit = pDevExt->HoldingEmpty && UartFlowCanTransmit(Device);
*HasErrors = ((pDevExt->LineStatus & SERIAL_LSR_ERROR) != 0);
FuncExit(TRACE_FLAG_REGUTIL);
}
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnReleaseHardware
//
// Called by WUDF to uninitialize the hardware.
//
// Parameters:
// pWdfDevice - pointer to an IWDFDevice object for the device
// pWdfResourcesTranslated - pointer to the translated resource list
//
// Return Values:
// status
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::OnReleaseHardware(
_In_ IWDFDevice3 * pWdfDevice,
_In_ IWDFCmResourceList * pWdfResourcesTranslated
)
{
FuncEntry();
UNREFERENCED_PARAMETER(pWdfDevice);
UNREFERENCED_PARAMETER(pWdfResourcesTranslated);
HRESULT hr = S_OK;
// Uninitialize and release the class extension.
if (m_spClassExtension != nullptr)
{
hr = m_spClassExtension->Uninitialize();
}
// Uninitialize the sensor DDI
if (m_pSensorDdi != nullptr)
{
m_pSensorDdi->Uninitialize();
SAFE_RELEASE(m_pSensorDdi);
}
// Release the IWDFDevice handle, if it matches
if (pWdfDevice == m_spWdfDevice.p)
{
m_spWdfDevice.Release();
}
FuncExit();
return hr;
}
VOID
ControllerUninitialize(
_In_ PPBC_DEVICE pDevice
)
/*++
Routine Description:
This routine uninitializes the controller hardware.
Arguments:
pDevice - a pointer to the PBC device context
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_PBCLOADING);
NT_ASSERT(pDevice != NULL);
// TODO: Uninitialize controller hardware via the
// pDevice->pRegisters->* register interface
// if necessary. Work may include disabling
// interrupts, etc.
UNREFERENCED_PARAMETER(pDevice);
FuncExit(TRACE_FLAG_PBCLOADING);
}
//
// Internal Function: UartCtlSetBreakOff
//
VOID
UartCtlSetBreakOff(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
UNREFERENCED_PARAMETER(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
//
// Software flow control and in-band signaling
// have not been implemented in this sample.
//
status = STATUS_NOT_IMPLEMENTED;
TraceMessage(TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
ControllerInitialize(
_In_ PPBC_DEVICE pDevice
)
/*++
Routine Description:
This routine initializes the controller hardware.
Arguments:
pDevice - a pointer to the PBC device context
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_PBCLOADING);
NT_ASSERT(pDevice != NULL);
// TODO: Initialize controller hardware via the
// pDevice->pRegisters->* register interface.
// Work may include configuring operating modes,
// FIFOs, clock, interrupts, etc.
UNREFERENCED_PARAMETER(pDevice);
FuncExit(TRACE_FLAG_PBCLOADING);
}
VOID
ControllerDisableInterrupts(
_In_ PPBC_DEVICE pDevice
)
/*++
Routine Description:
This routine disables all controller interrupts.
Arguments:
pDevice - a pointer to the PBC device context
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_TRANSFER);
NT_ASSERT(pDevice != NULL);
// TODO: Disable all interrupts.
UNREFERENCED_PARAMETER(pDevice);
FuncExit(TRACE_FLAG_TRANSFER);
}
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::CreateInstance
//
// This static method is used to create and initialize an instance of
// CMyDevice for use with a given hardware device.
//
// Parameters:
// pDriver - pointer to an IWDFDriver interface
// pDeviceInit - pointer to an interface used to intialize the device
// ppMyDevice - pointer to a location to place the CMyDevice instance
//
// Return Values:
// status
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::CreateInstance(
_In_ IWDFDriver* pDriver,
_In_ IWDFDeviceInitialize* pDeviceInit,
_Out_ CComObject<CMyDevice>** ppMyDevice
)
{
FuncEntry();
CComObject<CMyDevice>* pMyDevice = nullptr;
HRESULT hr = CComObject<CMyDevice>::CreateInstance(&pMyDevice);
if (SUCCEEDED(hr))
{
pMyDevice->AddRef();
hr = pMyDevice->Initialize(pDriver, pDeviceInit);
if (SUCCEEDED(hr))
{
*ppMyDevice = pMyDevice;
}
}
FuncExit();
return hr;
}
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::ProcessIoControl
//
// This method is a helper that takes the incoming IOCTL and forwards
// it to the Windows Sensor Class Extension for processing.
//
// Parameters:
// pQueue - pointer to the UMDF queue that
// handled the request
// pRequest - pointer to the request
// ControlCode - the IOCTL code
// InputBufferSizeInBytes - size of the incoming IOCTL buffer
// OutputBufferSizeInBytes - size of the outgoing IOCTL buffer
// pcbWritten - pointer to a DWORD containing the number
// of bytes returned
//
// Return Values:
// status
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::ProcessIoControl(
_In_ IWDFIoQueue* pQueue,
_In_ IWDFIoRequest* pRequest,
_In_ ULONG ControlCode,
SIZE_T InputBufferSizeInBytes,
SIZE_T OutputBufferSizeInBytes,
DWORD* pcbWritten)
{
FuncEntry();
UNREFERENCED_PARAMETER(pQueue);
UNREFERENCED_PARAMETER(ControlCode);
UNREFERENCED_PARAMETER(InputBufferSizeInBytes);
UNREFERENCED_PARAMETER(OutputBufferSizeInBytes);
UNREFERENCED_PARAMETER(pcbWritten);
HRESULT hr = S_OK;
if (m_spClassExtension == nullptr)
{
hr = E_POINTER;
}
if (SUCCEEDED(hr))
{
hr = m_spClassExtension->ProcessIoControl(pRequest);
}
FuncExit();
return hr;
}
//
// Internal Function: UartCtlSetFifoControl
//
VOID
UartCtlSetFifoControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR fifoControlRegister = 0;
UCHAR fifoControlRegisterSaved = 0;
PUCHAR pFifoControl = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(UCHAR),
(PVOID*)(& pFifoControl),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// This value is not verified. This is as specified in the documentation.
fifoControlRegister = *pFifoControl;
// Save the value of the FCR to be written, with the reset bits unset.
fifoControlRegisterSaved = fifoControlRegister &
(~(SERIAL_FCR_RCVR_RESET | SERIAL_FCR_TXMT_RESET));
// Acquires the interrupt lock and writes the FCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
WRITE_FIFO_CONTROL(pDevExt, pDevExt->Controller, fifoControlRegister);
pDevExt->FifoControl = fifoControlRegisterSaved;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlClearStats
//
VOID
UartCtlClearStats(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_SUCCESS;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
RtlZeroMemory(&pDevExt->PerfStats, sizeof(SERIALPERF_STATS));
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
ControllerAcknowledgeInterrupts(
_In_ PPBC_DEVICE pDevice,
_In_ ULONG InterruptMask
)
/*++
Routine Description:
This routine acknowledges the
specificed interrupt bits.
Arguments:
pDevice - a pointer to the PBC device context
InterruptMask - interrupt bits to acknowledge
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_TRANSFER);
NT_ASSERT(pDevice != NULL);
// TODO: Acknowledge requested interrupts.
UNREFERENCED_PARAMETER(pDevice);
UNREFERENCED_PARAMETER(InterruptMask);
FuncExit(TRACE_FLAG_TRANSFER);
}
//
// Internal Function: UartCtlSetChars
//
VOID
UartCtlSetChars(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_CHARS pSpecialChars = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_CHARS),
(PVOID*)(& pSpecialChars),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
//
// Software flow control and in-band signaling
// have not been implemented in this sample. Characters
// are not checked for valid range or values.
//
pDevExt->SpecialChars.EofChar = pSpecialChars->EofChar;
pDevExt->SpecialChars.ErrorChar = pSpecialChars->ErrorChar;
pDevExt->SpecialChars.BreakChar = pSpecialChars->BreakChar;
pDevExt->SpecialChars.EventChar = pSpecialChars->EventChar;
pDevExt->SpecialChars.XonChar = pSpecialChars->XonChar;
pDevExt->SpecialChars.XoffChar = pSpecialChars->XoffChar;
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
OnTopLevelIoDefault(
_In_ WDFQUEUE FxQueue,
_In_ WDFREQUEST FxRequest
)
/*++
Routine Description:
Accepts all incoming requests and pends or forwards appropriately.
Arguments:
FxQueue - Handle to the framework queue object that is associated with the
I/O request.
FxRequest - Handle to a framework request object.
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_SPBAPI);
UNREFERENCED_PARAMETER(FxQueue);
WDFDEVICE device;
PDEVICE_CONTEXT pDevice;
WDF_REQUEST_PARAMETERS params;
NTSTATUS status;
device = WdfIoQueueGetDevice(FxQueue);
pDevice = GetDeviceContext(device);
WDF_REQUEST_PARAMETERS_INIT(¶ms);
WdfRequestGetParameters(FxRequest, ¶ms);
status = WdfRequestForwardToIoQueue(FxRequest, pDevice->SpbQueue);
if (!NT_SUCCESS(status))
{
CyapaPrint(
DEBUG_LEVEL_ERROR,
DBG_IOCTL,
"Failed to forward WDFREQUEST %p to SPB queue %p - %!STATUS!",
FxRequest,
pDevice->SpbQueue,
status);
WdfRequestComplete(FxRequest, status);
}
FuncExit(TRACE_FLAG_SPBAPI);
}
const Func* Unit::getFunc(Offset pc) const {
FuncEntry key = FuncEntry(pc, NULL);
FuncTable::const_iterator it =
upper_bound(m_funcTable.begin(), m_funcTable.end(), key);
if (it != m_funcTable.end()) {
ASSERT(pc < it->pastOffset());
return it->val();
}
return NULL;
}
NTSTATUS
#pragma prefast(suppress:__WARNING_DRIVER_FUNCTION_TYPE, "thanks, i know this already")
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
{
/*WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);*/
NTSTATUS status = STATUS_SUCCESS;
WDF_DRIVER_CONFIG driverConfig;
WDF_OBJECT_ATTRIBUTES driverAttributes;
WDFDRIVER fxDriver;
WPP_INIT_TRACING(DriverObject, RegistryPath);
FuncEntry(TRACE_FLAG_WDFLOADING);
WDF_DRIVER_CONFIG_INIT(&driverConfig, OnDeviceAdd);
driverConfig.DriverPoolTag = SPBT_POOL_TAG;
WDF_OBJECT_ATTRIBUTES_INIT(&driverAttributes);
driverAttributes.EvtCleanupCallback = OnDriverCleanup;
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
&driverAttributes,
&driverConfig,
&fxDriver
);
if (!NT_SUCCESS(status))
{
Trace(
TRACE_LEVEL_ERROR,
TRACE_FLAG_WDFLOADING,
"Error creating WDF driver object - %!STATUS!",
status);
goto exit;
}
Trace(
TRACE_LEVEL_VERBOSE,
TRACE_FLAG_WDFLOADING,
"Created WDF driver object");
exit:
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
//
// Internal Function: UartCtlGetDtrrts
//
VOID
UartCtlGetDtrrts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UCHAR regModemControl;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(& pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= SERIAL_DTR_STATE | SERIAL_RTS_STATE;
*pBuffer = regModemControl;
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetBaudRate
//
VOID
UartCtlGetBaudRate(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_BAUD_RATE pBaudRate = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_BAUD_RATE),
(PVOID*)(& pBaudRate),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and retrieves the current baud rate.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
pBaudRate->BaudRate = pDevExt->CurrentBaud;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIAL_BAUD_RATE));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
USHORT UartWaitableEvents(
_In_ WDFDEVICE Device
)
{
PUART_DEVICE_EXTENSION pDevExt = NULL;
USHORT someEvent = 0;
pDevExt = UartGetDeviceExtension(Device);
FuncEntry(TRACE_FLAG_REGUTIL);
// Note that each if statement here is consistent in that it compares
// LineStatus to SERIAL_LSR_* and compares ModemStatus to SERIAL_MSR_*.
if ((pDevExt->LineStatus & SERIAL_LSR_DR) != 0)
someEvent = someEvent | SERIAL_EV_RXCHAR;
// SERIAL_EV_RXFLAG is not handled in this function.
if ((pDevExt->LineStatus & SERIAL_LSR_TEMT) != 0)
someEvent = someEvent | SERIAL_EV_TXEMPTY;
if ((pDevExt->LineStatus & SERIAL_LSR_BI) != 0)
someEvent = someEvent | SERIAL_EV_BREAK;
if ((pDevExt->LineStatus & SERIAL_LSR_ERROR) != 0)
someEvent = someEvent | SERIAL_EV_ERR;
if ((pDevExt->ModemStatus & SERIAL_MSR_DCTS) != 0)
someEvent = someEvent | SERIAL_EV_CTS;
if ((pDevExt->ModemStatus & SERIAL_MSR_DDSR) != 0)
someEvent = someEvent | SERIAL_EV_DSR;
if ((pDevExt->ModemStatus & SERIAL_MSR_TERI) != 0)
someEvent = someEvent | SERIAL_EV_RLSD;
if ((pDevExt->ModemStatus & SERIAL_MSR_RI) != 0)
someEvent = someEvent | SERIAL_EV_RING;
// SERIAL_EV_PERR is not possible.
// SERIAL_EV_RX80FULL is not handled in this function.
// SERIAL_EV_EVENT1 is not possible.
// SERIAL_EV_EVENT2 is not possible.
// Clear the modem status events
pDevExt->ModemStatus &= ~(SERIAL_MSR_EVENTS);
FuncExit(TRACE_FLAG_REGUTIL);
return someEvent;
}
//
// Internal Function: UartCtlGetModemControl
//
VOID
UartCtlGetModemControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(&pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and reads the modem control register.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pBuffer = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
OnDriverCleanup(
_In_ WDFOBJECT Object
)
{
FuncEntry(TRACE_FLAG_WDFLOADING);
UNREFERENCED_PARAMETER(Object);
WPP_CLEANUP(nullptr);
FuncExit(TRACE_FLAG_WDFLOADING);
}
//
// Internal Function: UartCtlGetStats
//
VOID
UartCtlGetStats(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIALPERF_STATS pStats = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIALPERF_STATS),
(PVOID*)(& pStats),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pStats = pDevExt->PerfStats;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIALPERF_STATS));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlClrRts
//
VOID
UartCtlClrRts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR regModemControl;
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
if (((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_RTS_HANDSHAKE) ||
((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_TRANSMIT_TOGGLE))
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"RTS cannot be cleared when automatic RTS flow control or "
"transmit toggling is used - %!STATUS!",
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and sets the MCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= ~SERIAL_MCR_RTS;
WRITE_MODEM_CONTROL(pDevExt, pDevExt->Controller, regModemControl);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetHandflow
//
VOID
UartCtlGetHandflow(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_HANDFLOW pHandFlow = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_HANDFLOW),
(PVOID*)(& pHandFlow),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
*pHandFlow = pDevExt->HandFlow;
WdfRequestSetInformation(Request, sizeof(SERIAL_HANDFLOW));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::OnCleanupFile
//
// This method is called when the file handle to the device is closed
//
// Parameters:
// pWdfFile - pointer to a file object
//
// Return Values:
// none
//
/////////////////////////////////////////////////////////////////////////
VOID CMyDevice::OnCleanupFile(
_In_ IWDFFile* pWdfFile
)
{
FuncEntry();
if (m_spClassExtension != nullptr)
{
m_spClassExtension->CleanupFile(pWdfFile);
}
FuncExit();
return;
}
//
// Internal Function: UartCtlSetDtr
//
VOID
UartCtlSetDtr(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR regModemControl;
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
if ((pDevExt->HandFlow.ControlHandShake & SERIAL_DTR_MASK) ==
SERIAL_DTR_HANDSHAKE)
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"DTR cannot be set when automatic DTR flow control is used - "
"%!STATUS!",
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and sets the MCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl |= SERIAL_MCR_DTR;
WRITE_MODEM_CONTROL(pDevExt, pDevExt->Controller, regModemControl);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
/////////////////////////////////////////////////////////////////////////
//
// CMyDevice::Configure
//
// This method is called after the device callback object has been initialized
// and returned to the driver. It would setup the device's queues and their
// corresponding callback objects.
//
// Parameters:
//
// Return Values:
// status
//
/////////////////////////////////////////////////////////////////////////
HRESULT CMyDevice::Configure()
{
FuncEntry();
HRESULT hr = CMyQueue::CreateInstance(m_spWdfDevice, this);
if (FAILED(hr))
{
Trace(
TRACE_LEVEL_ERROR,
"Failed to create instance of CMyQueue, %!HRESULT!",
hr);
}
FuncExit();
return hr;
}
NTSTATUS BOOTTRACKPAD(
_In_ PDEVICE_CONTEXT pDevice
)
{
NTSTATUS status = 0;
static char bl_exit[] = {
0x00, 0xff, 0xa5, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
static char bl_deactivate[] = {
0x00, 0xff, 0x3b, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
cyapa_boot_regs boot;
FuncEntry(TRACE_FLAG_WDFLOADING);
SpbReadDataSynchronously(&pDevice->I2CContext, CMD_BOOT_STATUS, &boot, sizeof(boot));
if ((boot.stat & CYAPA_STAT_RUNNING) == 0) {
if (boot.error & CYAPA_ERROR_BOOTLOADER)
SpbWriteDataSynchronously(&pDevice->I2CContext, CMD_BOOT_STATUS, bl_deactivate, sizeof(bl_deactivate));
else
SpbWriteDataSynchronously(&pDevice->I2CContext, CMD_BOOT_STATUS, bl_exit, sizeof(bl_exit));
}
WDF_TIMER_CONFIG timerConfig;
WDFTIMER hTimer;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_TIMER_CONFIG_INIT(&timerConfig, CyapaBootTimer);
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = pDevice->FxDevice;
status = WdfTimerCreate(&timerConfig, &attributes, &hTimer);
WdfTimerStart(hTimer, WDF_REL_TIMEOUT_IN_MS(75));
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}
NTSTATUS BOOTTRACKPAD(
_In_ PDEVICE_CONTEXT pDevice
)
{
if (deviceLoaded)
return 0;
NTSTATUS status = 0;
static char bl_exit[] = {
0x00, 0xff, 0xa5, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
FuncEntry(TRACE_FLAG_WDFLOADING);
SpbWriteDataSynchronously(&pDevice->I2CContext, 0x00, bl_exit, sizeof(bl_exit));
FuncExit(TRACE_FLAG_WDFLOADING);
deviceLoaded = true;
return status;
}
NTSTATUS
OnD0Entry(
_In_ WDFDEVICE FxDevice,
_In_ WDF_POWER_DEVICE_STATE FxPreviousState
)
/*++
Routine Description:
This routine allocates objects needed by the driver.
Arguments:
FxDevice - a handle to the framework device object
FxPreviousState - previous power state
Return Value:
Status
--*/
{
FuncEntry(TRACE_FLAG_WDFLOADING);
UNREFERENCED_PARAMETER(FxPreviousState);
PDEVICE_CONTEXT pDevice = GetDeviceContext(FxDevice);
NTSTATUS status = STATUS_SUCCESS;
WdfTimerStart(pDevice->Timer, WDF_REL_TIMEOUT_IN_MS(10));
BOOTTRACKPAD(pDevice);
pDevice->RegsSet = false;
pDevice->ConnectInterrupt = true;
FuncExit(TRACE_FLAG_WDFLOADING);
return status;
}