NTSTATUS
Acpi_EnumChildren (
_In_ PACPI_CONTEXT AcpiCtx,
_Out_ WDFMEMORY* EnumChildrenOutput
)
{
NTSTATUS status;
WDFDEVICE device;
WDFMEMORY inputMem;
PACPI_ENUM_CHILDREN_INPUT_BUFFER inputBuf;
size_t inputBufSize;
WDF_MEMORY_DESCRIPTOR inputMemDesc;
WDFMEMORY outputMem;
PACPI_ENUM_CHILDREN_OUTPUT_BUFFER outputBuf;
size_t outputBufSize;
WDF_MEMORY_DESCRIPTOR outputMemDesc;
WDF_OBJECT_ATTRIBUTES attributes;
PAGED_CODE();
TRACE_FUNC_ENTRY(TRACE_FLAG_ACPI);
device = Context_GetWdfDevice(AcpiCtx);
inputMem = WDF_NO_HANDLE;
outputMem = WDF_NO_HANDLE;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
inputBufSize = sizeof(*inputBuf);
status = WdfMemoryCreate(&attributes,
NonPagedPoolNx,
0,
inputBufSize,
&inputMem,
(PVOID*) &inputBuf);
if (!NT_SUCCESS(status))
{
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] WdfMemoryCreate for %Iu bytes failed", device, inputBufSize);
goto Exit;
}
RtlZeroMemory(inputBuf, inputBufSize);
inputBuf->Signature = ACPI_ENUM_CHILDREN_INPUT_BUFFER_SIGNATURE;
inputBuf->Flags = ENUM_CHILDREN_IMMEDIATE_ONLY;
WDF_MEMORY_DESCRIPTOR_INIT_HANDLE(&inputMemDesc, inputMem, nullptr);
outputBufSize = sizeof(*outputBuf);
do
{
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfMemoryCreate(&attributes,
NonPagedPoolNx,
0,
outputBufSize,
&outputMem,
(PVOID*) &outputBuf);
if (!NT_SUCCESS(status))
{
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] WdfMemoryCreate for %Iu bytes failed", device, outputBufSize);
goto Exit;
}
WDF_MEMORY_DESCRIPTOR_INIT_HANDLE(&outputMemDesc, outputMem, nullptr);
status = WdfIoTargetSendIoctlSynchronously(WdfDeviceGetIoTarget(device),
NULL,
IOCTL_ACPI_ENUM_CHILDREN,
&inputMemDesc,
&outputMemDesc,
nullptr,
nullptr);
if (NT_SUCCESS(status))
{
if (outputBuf->Signature != ACPI_ENUM_CHILDREN_OUTPUT_BUFFER_SIGNATURE)
{
status = STATUS_ACPI_INVALID_DATA;
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] Invalid data in ACPI_ENUM_CHILDREN_OUTPUT_BUFFER", device);
goto Exit;
}
//
// There must be atleast one, because this device is included in the list.
//
if (outputBuf->NumberOfChildren < 1)
{
status = STATUS_ACPI_INVALID_DATA;
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] No child devices in ACPI_ENUM_CHILDREN_OUTPUT_BUFFER", device);
goto Exit;
}
break;
}
if (status != STATUS_BUFFER_OVERFLOW)
{
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] IOCTL_ACPI_ENUM_CHILDREN failed - %!STATUS!", device, status);
goto Exit;
}
if (outputBuf->Signature != ACPI_ENUM_CHILDREN_OUTPUT_BUFFER_SIGNATURE)
{
status = STATUS_ACPI_INVALID_DATA;
TRACE_ERROR(TRACE_FLAG_ACPI, "[Device: 0x%p] Invalid data in ACPI_ENUM_CHILDREN_OUTPUT_BUFFER", device);
goto Exit;
}
outputBufSize = outputBuf->NumberOfChildren;
WdfObjectDelete(outputMem);
outputMem = WDF_NO_HANDLE;
#pragma warning(suppress:4127)
} while (true);
*EnumChildrenOutput = outputMem;
Exit:
if (inputMem != WDF_NO_HANDLE)
{
WdfObjectDelete(inputMem);
}
if (!NT_SUCCESS(status) && (outputMem != WDF_NO_HANDLE))
{
WdfObjectDelete(outputMem);
}
TRACE_FUNC_EXIT(TRACE_FLAG_ACPI);
return status;
}
NTSTATUS
BthEchoSharedGetHostSupportedFeatures(
_In_ PBTHECHOSAMPLE_DEVICE_CONTEXT_HEADER DevCtxHdr
)
/*++
Routine Description:
This routine synchronously checks the local stack's supported features
Arguments:
DevCtxHdr - Information about the local device
Return Value:
NTSTATUS Status code.
--*/
{
WDF_MEMORY_DESCRIPTOR outMemDesc = {0};
BTH_HOST_FEATURE_MASK localFeatures = {0};
NTSTATUS status = STATUS_SUCCESS;
DevCtxHdr->LocalFeatures.Mask = 0;
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&outMemDesc,
&localFeatures,
sizeof(localFeatures)
);
status = WdfIoTargetSendIoctlSynchronously(
DevCtxHdr->IoTarget,
NULL,
IOCTL_BTH_GET_HOST_SUPPORTED_FEATURES,
NULL,
&outMemDesc,
NULL,
NULL
);
if (!NT_SUCCESS(status)) {
return status;
}
DevCtxHdr->LocalFeatures = localFeatures;
return status;
}
NTSTATUS
BthEchoCliRetrieveServerSdpRecord(
__in PBTHECHOSAMPLE_CLIENT_CONTEXT DevCtx,
__out PBTH_SDP_STREAM_RESPONSE * ServerSdpRecord
)
/*++
Description:
Retrive server SDP record.
We call this function on every file open to get the PSM
Arguments:
DevCtx - Client context
ServerSdpRecord - SDP record retrieved
Return Value:
NTSTATUS Status code.
--*/
{
NTSTATUS status, statusReuse, disconnectStatus;
WDF_MEMORY_DESCRIPTOR inMemDesc;
WDF_MEMORY_DESCRIPTOR outMemDesc;
WDF_REQUEST_REUSE_PARAMS ReuseParams;
BTH_SDP_CONNECT connect = {0};
BTH_SDP_DISCONNECT disconnect = {0};
BTH_SDP_SERVICE_ATTRIBUTE_SEARCH_REQUEST requestSdp = {0};
BTH_SDP_STREAM_RESPONSE responseSdp = {0};
ULONG requestSize;
PBTH_SDP_STREAM_RESPONSE serverSdpRecord = NULL;
WDFREQUEST request;
WDF_OBJECT_ATTRIBUTES attributes;
PAGED_CODE();
//
// Allocate the request we will use for obtaining sdp record
// NOTE that we do it for every file open, hence we
//
// can't use reserve request from the context
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
status = WdfRequestCreate(
&attributes,
DevCtx->Header.IoTarget,
&request
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"Failed to allocate request for retriving server sdp record, Status code %!STATUS!\n", status);
goto exit;
}
connect.bthAddress = DevCtx->ServerBthAddress;
connect.requestTimeout = SDP_REQUEST_TO_DEFAULT;
connect.fSdpConnect = 0;
//
// Connect to the SDP service.
//
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&inMemDesc,
&connect,
sizeof(connect)
);
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&outMemDesc,
&connect,
sizeof(connect)
);
status = WdfIoTargetSendIoctlSynchronously(
DevCtx->Header.IoTarget,
request,
IOCTL_BTH_SDP_CONNECT,
&inMemDesc,
&outMemDesc,
NULL, //sendOptions
NULL //bytesReturned
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"IOCTL_BTH_SDP_CONNECT failed, Status code %!STATUS!\n", status);
goto exit1;
}
//
// Obtain the required size of the SDP record
//
requestSdp.hConnection = connect.hConnection;
requestSdp.uuids[0].u.uuid128 = BTHECHOSAMPLE_SVC_GUID;
requestSdp.uuids[0].uuidType = SDP_ST_UUID128;
requestSdp.range[0].minAttribute = 0;
requestSdp.range[0].maxAttribute = 0xFFFF;
WDF_REQUEST_REUSE_PARAMS_INIT(&ReuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_NOT_SUPPORTED);
statusReuse = WdfRequestReuse(request, &ReuseParams);
ASSERT(NT_SUCCESS(statusReuse));
UNREFERENCED_PARAMETER(statusReuse);
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&inMemDesc,
&requestSdp,
sizeof(requestSdp)
);
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&outMemDesc,
&responseSdp,
sizeof(responseSdp)
);
status = WdfIoTargetSendIoctlSynchronously(
DevCtx->Header.IoTarget,
request,
IOCTL_BTH_SDP_SERVICE_ATTRIBUTE_SEARCH,
&inMemDesc,
&outMemDesc,
NULL, //sendOptions
NULL //bytesReturned
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"IOCTL_BTH_SDP_SERVICE_ATTRIBUTE_SEARCH failed while querying response size, "
"status code %!STATUS!\n", status);
goto exit2;
}
//
// Allocate the required size for SDP record
//
status = RtlULongAdd(
responseSdp.requiredSize,
sizeof(BTH_SDP_STREAM_RESPONSE),
&requestSize
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"SDP record size too large, status code %!STATUS!\n", status);
goto exit2;
}
serverSdpRecord = ExAllocatePoolWithTag(NonPagedPool, requestSize, POOLTAG_BTHECHOSAMPLE);
if (NULL == serverSdpRecord)
{
status = STATUS_INSUFFICIENT_RESOURCES;
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"Allocating SDP record failed, returning status code %!STATUS!\n", status);
goto exit2;
}
//
// Send request with required size
//
WDF_REQUEST_REUSE_PARAMS_INIT(&ReuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_NOT_SUPPORTED);
statusReuse = WdfRequestReuse(request, &ReuseParams);
ASSERT(NT_SUCCESS(statusReuse));
UNREFERENCED_PARAMETER(statusReuse);
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&inMemDesc,
&requestSdp,
sizeof(requestSdp)
);
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&outMemDesc,
serverSdpRecord,
requestSize
);
status = WdfIoTargetSendIoctlSynchronously(
DevCtx->Header.IoTarget,
request,
IOCTL_BTH_SDP_SERVICE_ATTRIBUTE_SEARCH,
&inMemDesc,
&outMemDesc,
NULL, //sendOptions
NULL //bytesReturned
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_SDP,
"IOCTL_BTH_SDP_SERVICE_ATTRIBUTE_SEARCH failed, status code %!STATUS!\n", status);
ExFreePoolWithTag(serverSdpRecord, POOLTAG_BTHECHOSAMPLE);
}
else
{
*ServerSdpRecord = serverSdpRecord;
}
exit2:
//
// Disconnect from SDP service.
//
WDF_REQUEST_REUSE_PARAMS_INIT(&ReuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_NOT_SUPPORTED);
statusReuse = WdfRequestReuse(request, &ReuseParams);
ASSERT(NT_SUCCESS(statusReuse));
UNREFERENCED_PARAMETER(statusReuse);
disconnect.hConnection = connect.hConnection;
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(
&inMemDesc,
&disconnect,
sizeof(disconnect)
);
disconnectStatus = WdfIoTargetSendIoctlSynchronously(
DevCtx->Header.IoTarget,
request,
IOCTL_BTH_SDP_DISCONNECT,
&inMemDesc,
NULL, //outMemDesc
NULL, //sendOptions
NULL //bytesReturned
);
ASSERT(NT_SUCCESS(disconnectStatus)); //Disconnect should not fail
if (!NT_SUCCESS(disconnectStatus))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"IOCTL_BTH_SDP_DISCONNECT failed, Status code %!STATUS!\n", status);
}
exit1:
WdfObjectDelete(request);
exit:
return status;
}
NTSTATUS
FireflySetFeature(
IN PDEVICE_CONTEXT DeviceContext,
IN UCHAR PageId,
IN USHORT FeatureId,
IN BOOLEAN EnableFeature
)
/*++
Routine Description:
This routine sets the HID feature by sending HID ioctls to our device.
These IOCTLs will be handled by HIDUSB and converted into USB requests
and send to the device.
Arguments:
DeviceContext - Context for our device
PageID - UsagePage of the light control feature.
FeatureId - Usage ID of the feature.
EnanbleFeature - True to turn the light on, Falst to turn if off.
Return Value:
NT Status code
--*/
{
WDF_MEMORY_DESCRIPTOR inputDescriptor, outputDescriptor;
NTSTATUS status;
HID_COLLECTION_INFORMATION collectionInformation = {0};
PHIDP_PREPARSED_DATA preparsedData;
HIDP_CAPS caps;
USAGE usage;
ULONG usageLength;
PCHAR report;
WDFIOTARGET hidTarget;
WDF_IO_TARGET_OPEN_PARAMS openParams;
PAGED_CODE();
//
// Preinit for error.
//
preparsedData = NULL;
report = NULL;
hidTarget = NULL;
status = WdfIoTargetCreate(WdfObjectContextGetObject(DeviceContext),
WDF_NO_OBJECT_ATTRIBUTES,
&hidTarget);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: WdfIoTargetCreate failed 0x%x\n", status));
return status;
}
//
// Open it up, write access only!
//
WDF_IO_TARGET_OPEN_PARAMS_INIT_OPEN_BY_NAME(
&openParams,
&DeviceContext->PdoName,
FILE_WRITE_ACCESS);
//
// We will let the framework to respond automatically to the pnp
// state changes of the target by closing and opening the handle.
//
openParams.ShareAccess = FILE_SHARE_WRITE | FILE_SHARE_READ;
status = WdfIoTargetOpen(hidTarget, &openParams);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: WdfIoTargetOpen failed 0x%x\n", status));
goto ExitAndFree;
}
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&outputDescriptor,
(PVOID) &collectionInformation,
sizeof(HID_COLLECTION_INFORMATION));
//
// Now get the collection information for this device
//
status = WdfIoTargetSendIoctlSynchronously(hidTarget,
NULL,
IOCTL_HID_GET_COLLECTION_INFORMATION,
NULL,
&outputDescriptor,
NULL,
NULL);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: WdfIoTargetSendIoctlSynchronously failed 0x%x\n", status));
goto ExitAndFree;
}
preparsedData = (PHIDP_PREPARSED_DATA) ExAllocatePoolWithTag(
NonPagedPool, collectionInformation.DescriptorSize, 'ffly');
if (preparsedData == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto ExitAndFree;
}
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&outputDescriptor,
(PVOID) preparsedData,
collectionInformation.DescriptorSize);
status = WdfIoTargetSendIoctlSynchronously(hidTarget,
NULL,
IOCTL_HID_GET_COLLECTION_DESCRIPTOR,
NULL,
&outputDescriptor,
NULL,
NULL);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: WdfIoTargetSendIoctlSynchronously failed 0x%x\n", status));
goto ExitAndFree;
}
//
// Now get the capabilities.
//
RtlZeroMemory(&caps, sizeof(HIDP_CAPS));
status = HidP_GetCaps(preparsedData, &caps);
if (!NT_SUCCESS(status)) {
goto ExitAndFree;
}
//
// Create a report to send to the device.
//
report = (PCHAR) ExAllocatePoolWithTag(
NonPagedPool, caps.FeatureReportByteLength, 'ffly');
if (report == NULL) {
goto ExitAndFree;
}
//
// Start with a zeroed report. If we are disabling the feature, this might
// be all we need to do.
//
RtlZeroMemory(report, caps.FeatureReportByteLength);
status = STATUS_SUCCESS;
if (EnableFeature) {
//
// Edit the report to reflect the enabled feature
//
usage = FeatureId;
usageLength = 1;
status = HidP_SetUsages(
HidP_Feature,
PageId,
0,
&usage, // pointer to the usage list
&usageLength, // number of usages in the usage list
preparsedData,
report,
caps.FeatureReportByteLength
);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: HidP_SetUsages failed 0x%x\n", status));
goto ExitAndFree;
}
}
WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDescriptor,
report,
caps.FeatureReportByteLength);
status = WdfIoTargetSendIoctlSynchronously(hidTarget,
NULL,
IOCTL_HID_SET_FEATURE,
&inputDescriptor,
NULL,
NULL,
NULL);
if (!NT_SUCCESS(status)) {
KdPrint(("FireFly: WdfIoTargetSendIoctlSynchronously failed 0x%x\n", status));
goto ExitAndFree;
}
ExitAndFree:
if (preparsedData != NULL) {
ExFreePool(preparsedData);
preparsedData = NULL;
}
if (report != NULL) {
ExFreePool(report);
report = NULL;
}
if (hidTarget != NULL) {
WdfObjectDelete(hidTarget);
}
return status;
}
