hdaudbus.h File Reference

#include <ntddk.h>
#include <initguid.h>
#include <hdaudio.h>
#include <stdio.h>
#include <ntstrsafe.h>
#include "driver.h"
#include <debug.h>

Include dependency graph for hdaudbus.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	RIRB_RESPONSE
struct	HDA_CODEC_AUDIO_GROUP
struct	HDA_CODEC_ENTRY
struct	HDA_FDO_DEVICE_EXTENSION
struct	HDA_PDO_DEVICE_EXTENSION
struct	CODEC_RESPONSE

Macros
#define	NDEBUG
#define	TAG_HDA   'bADH'
#define	MAKE_RATE(base, multiply, divide)
#define	HDAC_INPUT_STREAM_OFFSET(index)    ((index) * HDAC_STREAM_SIZE)
#define	HDAC_OUTPUT_STREAM_OFFSET(num_input_streams, index)    ((num_input_streams + (index)) * HDAC_STREAM_SIZE)
#define	HDAC_BIDIR_STREAM_OFFSET(num_input_streams, num_output_streams, index)
#define	ALIGN(size, align)   (((size) + align - 1) & ~(align - 1))

Typedefs
typedef struct RIRB_RESPONSE *	PRIRB_RESPONSE
typedef struct HDA_CODEC_AUDIO_GROUP *	PHDA_CODEC_AUDIO_GROUP
typedef struct HDA_CODEC_ENTRY *	PHDA_CODEC_ENTRY
typedef struct HDA_FDO_DEVICE_EXTENSION *	PHDA_FDO_DEVICE_EXTENSION
typedef struct HDA_PDO_DEVICE_EXTENSION *	PHDA_PDO_DEVICE_EXTENSION
typedef struct CODEC_RESPONSE *	PCODEC_RESPONSE

Functions
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID	FreeItem (IN PVOID Item)
NTSTATUS NTAPI	HDA_FDOStartDevice (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	HDA_FDORemoveDevice (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS NTAPI	HDA_FDOQueryBusRelations (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	HDA_SendVerbs (IN PDEVICE_OBJECT DeviceObject, IN PHDA_CODEC_ENTRY Codec, IN PULONG Verbs, OUT PULONG Responses, IN ULONG Count)
NTSTATUS	HDA_PDORemoveDevice (_In_ PDEVICE_OBJECT DeviceObject)
NTSTATUS	HDA_PDOQueryBusInformation (IN PIRP Irp)
NTSTATUS NTAPI	HDA_PDOQueryId (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	HDA_PDOHandleQueryDeviceText (IN PIRP Irp)
NTSTATUS	HDA_PDOQueryBusDeviceCapabilities (IN PIRP Irp)
NTSTATUS	HDA_PDOQueryBusDevicePnpState (IN PIRP Irp)
NTSTATUS	HDA_PDOHandleQueryInterface (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

Variables
KSERVICE_ROUTINE	HDA_InterruptService
IO_DPC_ROUTINE	HDA_DpcForIsr

Macro Definition Documentation

ALIGN

#define ALIGN	(		size,
			align
	)		(((size) + align - 1) & ~(align - 1))

Definition at line 30 of file hdaudbus.h.

HDAC_BIDIR_STREAM_OFFSET

#define HDAC_BIDIR_STREAM_OFFSET	(		num_input_streams,
			num_output_streams,
			index
	)

Value:

    ((num_input_streams + num_output_streams \
        + (index)) * HDAC_STREAM_SIZE)

Definition at line 26 of file hdaudbus.h.

HDAC_INPUT_STREAM_OFFSET

#define HDAC_INPUT_STREAM_OFFSET

(

index

)

((index) * HDAC_STREAM_SIZE)

Definition at line 22 of file hdaudbus.h.

HDAC_OUTPUT_STREAM_OFFSET

#define HDAC_OUTPUT_STREAM_OFFSET	(		num_input_streams,
			index
	)		((num_input_streams + (index)) * HDAC_STREAM_SIZE)

Definition at line 24 of file hdaudbus.h.

MAKE_RATE

#define MAKE_RATE	(		base,
			multiply,
			divide
	)

Value:

    ((base == 44100 ? FORMAT_44_1_BASE_RATE : 0) \
        | ((multiply - 1) << FORMAT_MULTIPLY_RATE_SHIFT) \
        | ((divide - 1) << FORMAT_DIVIDE_RATE_SHIFT))

Definition at line 17 of file hdaudbus.h.

NDEBUG

#define NDEBUG

Definition at line 12 of file hdaudbus.h.

TAG_HDA

#define TAG_HDA   'bADH'

Definition at line 15 of file hdaudbus.h.

Typedef Documentation

PCODEC_RESPONSE

typedef struct CODEC_RESPONSE * PCODEC_RESPONSE

PHDA_CODEC_AUDIO_GROUP

typedef struct HDA_CODEC_AUDIO_GROUP * PHDA_CODEC_AUDIO_GROUP

PHDA_CODEC_ENTRY

typedef struct HDA_CODEC_ENTRY * PHDA_CODEC_ENTRY

PHDA_FDO_DEVICE_EXTENSION

typedef struct HDA_FDO_DEVICE_EXTENSION * PHDA_FDO_DEVICE_EXTENSION

PHDA_PDO_DEVICE_EXTENSION

typedef struct HDA_PDO_DEVICE_EXTENSION * PHDA_PDO_DEVICE_EXTENSION

PRIRB_RESPONSE

typedef struct RIRB_RESPONSE * PRIRB_RESPONSE

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

HDA_FDOQueryBusRelations()

NTSTATUS NTAPI HDA_FDOQueryBusRelations	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 761 of file fdo.cpp.

{
    ULONG DeviceCount, CodecIndex, AFGIndex;
    PHDA_FDO_DEVICE_EXTENSION DeviceExtension;
    PHDA_CODEC_ENTRY Codec;
    PDEVICE_RELATIONS DeviceRelations;
 
    /* get device extension */
    DeviceExtension = (PHDA_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->IsFDO == TRUE);
 
    DeviceCount = 0;
    for (CodecIndex = 0; CodecIndex < HDA_MAX_CODECS; CodecIndex++)
    {
        if (DeviceExtension->Codecs[CodecIndex] == NULL)
            continue;
 
        Codec = DeviceExtension->Codecs[CodecIndex];
        DeviceCount += Codec->AudioGroupCount;
    }
 
    if (DeviceCount == 0)
        return STATUS_UNSUCCESSFUL;
 
    DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(NonPagedPool, sizeof(DEVICE_RELATIONS) + (DeviceCount > 1 ? sizeof(PDEVICE_OBJECT) * (DeviceCount - 1) : 0));
    if (!DeviceRelations)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    DeviceRelations->Count = 0;
    for (CodecIndex = 0; CodecIndex < HDA_MAX_CODECS; CodecIndex++)
    {
        if (DeviceExtension->Codecs[CodecIndex] == NULL)
            continue;
 
        Codec = DeviceExtension->Codecs[CodecIndex];
        ASSERT(Codec->AudioGroupCount <= HDA_MAX_AUDIO_GROUPS);
        for (AFGIndex = 0; AFGIndex < Codec->AudioGroupCount; AFGIndex++)
        {
            DeviceRelations->Objects[DeviceRelations->Count] = Codec->AudioGroups[AFGIndex]->ChildPDO;
            ObReferenceObject(Codec->AudioGroups[AFGIndex]->ChildPDO);
            DeviceRelations->Count++;
        }
    }
 
    /* FIXME handle existing device relations */
    ASSERT(Irp->IoStatus.Information == 0);
 
    /* store device relations */
    Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by HDA_FdoPnp().

HDA_FDORemoveDevice()

NTSTATUS NTAPI HDA_FDORemoveDevice	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 693 of file fdo.cpp.

{
    NTSTATUS Status;
    PHDA_FDO_DEVICE_EXTENSION DeviceExtension;
    ULONG CodecIndex, AFGIndex;
    PHDA_CODEC_ENTRY CodecEntry;
    PDEVICE_OBJECT ChildPDO;
    PHDA_PDO_DEVICE_EXTENSION ChildDeviceExtension;
 
    /* get device extension */
    DeviceExtension = static_cast<PHDA_FDO_DEVICE_EXTENSION>(DeviceObject->DeviceExtension);
    ASSERT(DeviceExtension->IsFDO == TRUE);
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoSkipCurrentIrpStackLocation(Irp);
    Status = IoCallDriver(DeviceExtension->LowerDevice, Irp);
 
    IoDetachDevice(DeviceExtension->LowerDevice);
 
    if (DeviceExtension->RegBase != NULL)
    {
        MmUnmapIoSpace(DeviceExtension->RegBase,
                       DeviceExtension->RegLength);
    }
    if (DeviceExtension->Interrupt != NULL)
    {
        IoDisconnectInterrupt(DeviceExtension->Interrupt);
    }
    if (DeviceExtension->CorbBase != NULL)
    {
        MmFreeContiguousMemory(DeviceExtension->CorbBase);
    }
 
    for (CodecIndex = 0; CodecIndex < HDA_MAX_CODECS; CodecIndex++)
    {
        CodecEntry = DeviceExtension->Codecs[CodecIndex];
        if (CodecEntry == NULL)
        {
            continue;
        }
 
        ASSERT(CodecEntry->AudioGroupCount <= HDA_MAX_AUDIO_GROUPS);
        for (AFGIndex = 0; AFGIndex < CodecEntry->AudioGroupCount; AFGIndex++)
        {
            ChildPDO = CodecEntry->AudioGroups[AFGIndex]->ChildPDO;
            if (ChildPDO != NULL)
            {
                ChildDeviceExtension = static_cast<PHDA_PDO_DEVICE_EXTENSION>(ChildPDO->DeviceExtension);
                ChildDeviceExtension->Codec = NULL;
                ChildDeviceExtension->AudioGroup = NULL;
                ChildDeviceExtension->FDO = NULL;
                ChildDeviceExtension->ReportedMissing = TRUE;
                HDA_PDORemoveDevice(ChildPDO);
            }
            FreeItem(CodecEntry->AudioGroups[AFGIndex]);
        }
        FreeItem(CodecEntry);
    }
 
    IoDeleteDevice(DeviceObject);
 
    return Status;
}

Referenced by HDA_FdoPnp().

HDA_FDOStartDevice()

NTSTATUS NTAPI HDA_FDOStartDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 579 of file fdo.cpp.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status = STATUS_SUCCESS;
    PHDA_FDO_DEVICE_EXTENSION DeviceExtension;
    PCM_RESOURCE_LIST Resources;
    ULONG Index;
    USHORT Value;
 
    /* get device extension */
    DeviceExtension = (PHDA_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->IsFDO == TRUE);
 
    /* forward irp to lower device */
    if (!IoForwardIrpSynchronously(DeviceExtension->LowerDevice, Irp))
    {
        ASSERT(FALSE);
        return STATUS_INVALID_DEVICE_REQUEST;
    }
    Status = Irp->IoStatus.Status;
    if (!NT_SUCCESS(Status))
    {
        // failed to start
        DPRINT1("HDA_StartDevice Lower device failed to start %x\n", Status);
        return Status;
    }
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    Resources = IoStack->Parameters.StartDevice.AllocatedResourcesTranslated;
    for (Index = 0; Index < Resources->List[0].PartialResourceList.Count; Index++)
    {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor = &Resources->List[0].PartialResourceList.PartialDescriptors[Index];
 
        if (Descriptor->Type == CmResourceTypeMemory)
        {
            DeviceExtension->RegLength = Descriptor->u.Memory.Length;
            DeviceExtension->RegBase = (PUCHAR)MmMapIoSpace(Descriptor->u.Memory.Start, Descriptor->u.Memory.Length, MmNonCached);
            if (DeviceExtension->RegBase == NULL)
            {
                DPRINT1("[HDAB] Failed to map registers\n");
                Status = STATUS_UNSUCCESSFUL;
                break;
            }
        }
        else if (Descriptor->Type == CmResourceTypeInterrupt)
        {
            Status = IoConnectInterrupt(&DeviceExtension->Interrupt,
                HDA_InterruptService,
                DeviceObject,
                NULL,
                Descriptor->u.Interrupt.Vector,
                Descriptor->u.Interrupt.Level,
                Descriptor->u.Interrupt.Level,
                (KINTERRUPT_MODE)(Descriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED),
                (Descriptor->ShareDisposition != CmResourceShareDeviceExclusive),
                Descriptor->u.Interrupt.Affinity,
                FALSE);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("[HDAB] Failed to connect interrupt. Status=%lx\n", Status);
                break;
            }
 
        }
    }
 
    if (NT_SUCCESS(Status))
    {
        // Get controller into valid state
        Status = HDA_ResetController(DeviceObject);
        if (!NT_SUCCESS(Status)) return Status;
 
        // Setup CORB/RIRB/DMA POS
        Status = HDA_InitCorbRirbPos(DeviceObject);
        if (!NT_SUCCESS(Status)) return Status;
 
 
        // Don't enable codec state change interrupts. We don't handle
        // them, as we want to use the STATE_STATUS register to identify
        // available codecs. We'd have to clear that register in the interrupt
        // handler to 'ack' the codec change.
        Value = READ_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_WAKE_ENABLE)) & ~HDAC_WAKE_ENABLE_MASK;
        WRITE_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_WAKE_ENABLE), Value);
 
        // Enable controller interrupts
        WRITE_REGISTER_ULONG((PULONG)(DeviceExtension->RegBase + HDAC_INTR_CONTROL), INTR_CONTROL_GLOBAL_ENABLE | INTR_CONTROL_CONTROLLER_ENABLE);
 
        KeStallExecutionProcessor(1000);
 
        Value = READ_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_STATE_STATUS));
        if (!Value) {
            DPRINT1("hda: bad codec status\n");
            return STATUS_UNSUCCESSFUL;
        }
        WRITE_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_STATE_STATUS), Value);
 
        // Create codecs
        DPRINT1("Codecs %lx\n", Value);
        for (Index = 0; Index < HDA_MAX_CODECS; Index++) {
            if ((Value & (1 << Index)) != 0) {
                HDA_InitCodec(DeviceObject, Index);
            }
        }
    }
 
    return Status;
}

Referenced by HDA_FdoPnp().

HDA_PDOHandleQueryDeviceText()

NTSTATUS HDA_PDOHandleQueryDeviceText

(

IN PIRP

Irp

)

Definition at line 154 of file pdo.cpp.

{
    PIO_STACK_LOCATION IoStack;
    LPWSTR Buffer;
    static WCHAR DeviceText[] = L"Audio Device on High Definition Audio Bus";
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    if (IoStack->Parameters.QueryDeviceText.DeviceTextType == DeviceTextDescription)
    {
        DPRINT("HDA_PdoHandleQueryDeviceText DeviceTextDescription\n");
 
        Buffer = (LPWSTR)AllocateItem(PagedPool, sizeof(DeviceText));
        if (!Buffer)
        {
            Irp->IoStatus.Information = 0;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        wcscpy(Buffer, DeviceText);
 
        Irp->IoStatus.Information = (ULONG_PTR)Buffer;
        return STATUS_SUCCESS;
    }
    else
    {
        DPRINT("HDA_PdoHandleQueryDeviceText DeviceTextLocationInformation\n");
 
        Buffer = (LPWSTR)AllocateItem(PagedPool, sizeof(DeviceText));
        if (!Buffer)
        {
            Irp->IoStatus.Information = 0;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        wcscpy(Buffer, DeviceText);
 
        /* save result */
        Irp->IoStatus.Information = (ULONG_PTR)Buffer;
        return STATUS_SUCCESS;
    }
 
}

Referenced by HDA_PdoPnp().

HDA_PDOHandleQueryInterface()

NTSTATUS HDA_PDOHandleQueryInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 299 of file businterface.cpp.

{
    PIO_STACK_LOCATION IoStack;
    PHDAUDIO_BUS_INTERFACE_V2 InterfaceHDA;
    PHDA_PDO_DEVICE_EXTENSION DeviceExtension;
 
    /* get device extension */
    DeviceExtension = (PHDA_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->IsFDO == FALSE);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IsEqualGUIDAligned(*IoStack->Parameters.QueryInterface.InterfaceType, GUID_HDAUDIO_BUS_INTERFACE))
    {
        InterfaceHDA = (PHDAUDIO_BUS_INTERFACE_V2)IoStack->Parameters.QueryInterface.Interface;
        InterfaceHDA->Version = IoStack->Parameters.QueryInterface.Version;
        InterfaceHDA->Size = sizeof(HDAUDIO_BUS_INTERFACE);
        InterfaceHDA->Context = DeviceExtension;
        InterfaceHDA->InterfaceReference = HDA_InterfaceReference;
        InterfaceHDA->InterfaceDereference = HDA_InterfaceDereference;
 
        InterfaceHDA->TransferCodecVerbs = HDA_TransferCodecVerbs;
        InterfaceHDA->AllocateCaptureDmaEngine = HDA_AllocateCaptureDmaEngine;
        InterfaceHDA->AllocateRenderDmaEngine = HDA_AllocateRenderDmaEngine;
        InterfaceHDA->ChangeBandwidthAllocation = HDA_ChangeBandwidthAllocation;
        InterfaceHDA->AllocateDmaBuffer = HDA_AllocateDmaBuffer;
        InterfaceHDA->FreeDmaBuffer = HDA_FreeDmaBuffer;
        InterfaceHDA->FreeDmaEngine = HDA_FreeDmaEngine;
        InterfaceHDA->SetDmaEngineState = HDA_SetDmaEngineState;
        InterfaceHDA->GetWallClockRegister = HDA_GetWallClockRegister;
        InterfaceHDA->GetLinkPositionRegister = HDA_GetLinkPositionRegister;
        InterfaceHDA->RegisterEventCallback = HDA_RegisterEventCallback;
        InterfaceHDA->UnregisterEventCallback = HDA_UnregisterEventCallback;
        InterfaceHDA->GetDeviceInformation = HDA_GetDeviceInformation;
        InterfaceHDA->GetResourceInformation = HDA_GetResourceInformation;
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUIDAligned(*IoStack->Parameters.QueryInterface.InterfaceType, GUID_HDAUDIO_BUS_INTERFACE_V2))
    {
        InterfaceHDA = (PHDAUDIO_BUS_INTERFACE_V2)IoStack->Parameters.QueryInterface.Interface;
        InterfaceHDA->Version = IoStack->Parameters.QueryInterface.Version;
        InterfaceHDA->Size = sizeof(HDAUDIO_BUS_INTERFACE_V2);
        InterfaceHDA->Context = DeviceExtension;
        InterfaceHDA->InterfaceReference = HDA_InterfaceReference;
        InterfaceHDA->InterfaceDereference = HDA_InterfaceDereference;
 
        InterfaceHDA->TransferCodecVerbs = HDA_TransferCodecVerbs;
        InterfaceHDA->AllocateCaptureDmaEngine = HDA_AllocateCaptureDmaEngine;
        InterfaceHDA->AllocateRenderDmaEngine = HDA_AllocateRenderDmaEngine;
        InterfaceHDA->ChangeBandwidthAllocation = HDA_ChangeBandwidthAllocation;
        InterfaceHDA->AllocateDmaBuffer = HDA_AllocateDmaBuffer;
        InterfaceHDA->FreeDmaBuffer = HDA_FreeDmaBuffer;
        InterfaceHDA->FreeDmaEngine = HDA_FreeDmaEngine;
        InterfaceHDA->SetDmaEngineState = HDA_SetDmaEngineState;
        InterfaceHDA->GetWallClockRegister = HDA_GetWallClockRegister;
        InterfaceHDA->GetLinkPositionRegister = HDA_GetLinkPositionRegister;
        InterfaceHDA->RegisterEventCallback = HDA_RegisterEventCallback;
        InterfaceHDA->UnregisterEventCallback = HDA_UnregisterEventCallback;
        InterfaceHDA->GetDeviceInformation = HDA_GetDeviceInformation;
        InterfaceHDA->GetResourceInformation = HDA_GetResourceInformation;
 
        InterfaceHDA->AllocateDmaBufferWithNotification = HDA_AllocateDmaBufferWithNotification;
        InterfaceHDA->FreeDmaBufferWithNotification = HDA_FreeDmaBufferWithNotification;
        InterfaceHDA->RegisterNotificationEvent = HDA_RegisterNotificationEvent;
        InterfaceHDA->UnregisterNotificationEvent = HDA_UnregisterNotificationEvent;
    }
 
    // FIXME
    // implement support for GUID_HDAUDIO_BUS_INTERFACE_BDL
    UNIMPLEMENTED;
    return STATUS_NOT_SUPPORTED;
}

Referenced by HDA_PdoPnp().

HDA_PDOQueryBusDeviceCapabilities()

NTSTATUS HDA_PDOQueryBusDeviceCapabilities

(

IN PIRP

Irp

)

Definition at line 199 of file pdo.cpp.

{
    PDEVICE_CAPABILITIES Capabilities;
    PIO_STACK_LOCATION IoStack;
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get capabilities */
    Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
 
    RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
 
    /* setup capabilities */
    Capabilities->UniqueID = TRUE;
    Capabilities->SilentInstall = TRUE;
    Capabilities->SurpriseRemovalOK = TRUE;
    Capabilities->Address = 0;
    Capabilities->UINumber = 0;
    Capabilities->SystemWake = PowerSystemWorking; /* FIXME common device extension */
    Capabilities->DeviceWake = PowerDeviceD0;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by HDA_PdoPnp().

HDA_PDOQueryBusDevicePnpState()

NTSTATUS HDA_PDOQueryBusDevicePnpState

(

IN PIRP

Irp

)

Definition at line 227 of file pdo.cpp.

{
    /* set device flags */
    Irp->IoStatus.Information = PNP_DEVICE_DONT_DISPLAY_IN_UI | PNP_DEVICE_NOT_DISABLEABLE;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by HDA_PdoPnp().

HDA_PDOQueryBusInformation()

NTSTATUS HDA_PDOQueryBusInformation

(

IN PIRP

Irp

)

Definition at line 33 of file pdo.cpp.

{
    PPNP_BUS_INFORMATION BusInformation;
 
    /* allocate bus information */
    BusInformation = (PPNP_BUS_INFORMATION)AllocateItem(PagedPool, sizeof(PNP_BUS_INFORMATION));
 
    if (!BusInformation)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* return info */
    BusInformation->BusNumber = 0;
    BusInformation->LegacyBusType = PCIBus;
    RtlMoveMemory(&BusInformation->BusTypeGuid, &GUID_HDAUDIO_BUS_INTERFACE, sizeof(GUID));
 
    /* store result */
    Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by HDA_PdoPnp().

HDA_PDOQueryId()

NTSTATUS NTAPI HDA_PDOQueryId	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 62 of file pdo.cpp.

{
    PIO_STACK_LOCATION IoStack;
    WCHAR DeviceName[200];
    PHDA_PDO_DEVICE_EXTENSION DeviceExtension;
    ULONG Length;
    LPWSTR Device;
    NTSTATUS Status;
 
    /* get device extension */
    DeviceExtension = (PHDA_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->IsFDO == FALSE);
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
    {
        Status = RtlStringCbPrintfW(DeviceName,
                                    sizeof(DeviceName),
                                    L"%02x%02x",
                                    DeviceExtension->Codec->Addr,
                                    DeviceExtension->AudioGroup->NodeId);
        NT_ASSERT(NT_SUCCESS(Status));
        Length = wcslen(DeviceName) + 1;
 
        /* allocate result buffer*/
        Device = (LPWSTR)AllocateItem(PagedPool, Length * sizeof(WCHAR));
        if (!Device)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        Status = RtlStringCbCopyW(Device,
                                  Length * sizeof(WCHAR),
                                  DeviceName);
        NT_ASSERT(NT_SUCCESS(Status));
 
        DPRINT1("ID: %S\n", Device);
        /* store result */
        Irp->IoStatus.Information = (ULONG_PTR)Device;
        return STATUS_SUCCESS;
    }
    else if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID ||
        IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
    {
 
        /* calculate size */
        swprintf(DeviceName, L"HDAUDIO\\FUNC_%02X&VEN_%04X&DEV_%04X&SUBSYS_%08X", DeviceExtension->AudioGroup->FunctionGroup, DeviceExtension->Codec->VendorId, DeviceExtension->Codec->ProductId, DeviceExtension->Codec->VendorId << 16 | DeviceExtension->Codec->ProductId);
        Length = wcslen(DeviceName) + 20;
 
        /* allocate result buffer*/
        Device = (LPWSTR)AllocateItem(PagedPool, Length * sizeof(WCHAR));
        if (!Device)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        wcscpy(Device, DeviceName);
 
        DPRINT1("ID: %S\n", Device);
        /* store result */
        Irp->IoStatus.Information = (ULONG_PTR)Device;
        return STATUS_SUCCESS;
    }
    else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
    {
        RtlZeroMemory(DeviceName, sizeof(DeviceName));
        Length = swprintf(DeviceName, L"HDAUDIO\\FUNC_%02X&VEN_%04X&DEV_%04X&REV_%04X", DeviceExtension->AudioGroup->FunctionGroup, DeviceExtension->Codec->VendorId, DeviceExtension->Codec->ProductId, DeviceExtension->Codec->Major << 12 | DeviceExtension->Codec->Minor << 8 | DeviceExtension->Codec->Revision) + 1;
        Length += swprintf(&DeviceName[Length], L"HDAUDIO\\FUNC_%02X&VEN_%04X&DEV_%04X", DeviceExtension->AudioGroup->FunctionGroup, DeviceExtension->Codec->VendorId, DeviceExtension->Codec->ProductId) + 1;
        Length += swprintf(&DeviceName[Length], L"HDAUDIO\\FUNC_%02X&VEN_%04X", DeviceExtension->AudioGroup->FunctionGroup, DeviceExtension->Codec->VendorId) + 1;
        Length += swprintf(&DeviceName[Length], L"HDAUDIO\\FUNC_%02X", DeviceExtension->AudioGroup->FunctionGroup) + 2;
 
        /* allocate result buffer*/
        Device = (LPWSTR)AllocateItem(PagedPool, Length * sizeof(WCHAR));
        if (!Device)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        RtlCopyMemory(Device, DeviceName, Length * sizeof(WCHAR));
 
        DPRINT1("ID: %S\n", Device);
        /* store result */
        Irp->IoStatus.Information = (ULONG_PTR)Device;
        return STATUS_SUCCESS;
    }
    else
    {
        DPRINT1("QueryID Type %x not implemented\n", IoStack->Parameters.QueryId.IdType);
        return Irp->IoStatus.Status;
    }
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by HDA_PdoPnp().

HDA_PDORemoveDevice()

NTSTATUS HDA_PDORemoveDevice

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 11 of file pdo.cpp.

{
    PHDA_PDO_DEVICE_EXTENSION DeviceExtension;
 
    /* get device extension */
    DeviceExtension = static_cast<PHDA_PDO_DEVICE_EXTENSION>(DeviceObject->DeviceExtension);
    ASSERT(DeviceExtension->IsFDO == FALSE);
 
    if (DeviceExtension->ReportedMissing)
    {
        if (DeviceExtension->AudioGroup != NULL)
        {
            DeviceExtension->AudioGroup->ChildPDO = NULL;
        }
        IoDeleteDevice(DeviceObject);
    }
 
    return STATUS_SUCCESS;
}

Referenced by HDA_FDORemoveDevice(), and HDA_PdoPnp().

HDA_SendVerbs()

NTSTATUS HDA_SendVerbs	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PHDA_CODEC_ENTRY	Codec,
		IN PULONG	Verbs,
		OUT PULONG	Responses,
		IN ULONG	Count
	)

Definition at line 139 of file fdo.cpp.

{
    PHDA_FDO_DEVICE_EXTENSION DeviceExtension;
    ULONG Sent = 0, ReadPosition, WritePosition, Queued;
 
    /* get device extension */
    DeviceExtension = (PHDA_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->IsFDO);
 
    /* reset response count */
    Codec->ResponseCount = 0;
 
    while (Sent < Count) {
        ReadPosition = READ_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_CORB_READ_POS));
 
        Queued = 0;
 
        while (Sent < Count) {
            WritePosition = (DeviceExtension->CorbWritePos + 1) % DeviceExtension->CorbLength;
 
            if (WritePosition == ReadPosition) {
                // There is no space left in the ring buffer; execute the
                // queued commands and wait until
                break;
            }
 
            DeviceExtension->CorbBase[WritePosition] = Verbs[Sent++];
            DeviceExtension->CorbWritePos = WritePosition;
            Queued++;
        }
 
        WRITE_REGISTER_USHORT((PUSHORT)(DeviceExtension->RegBase + HDAC_CORB_WRITE_POS), DeviceExtension->CorbWritePos);
    }
 
    while (Queued--)
    {
        LARGE_INTEGER Timeout;
        Timeout.QuadPart = -1000LL * 10000; // 1 sec
 
        NTSTATUS waitStatus = KeWaitForSingleObject(&Codec->ResponseSemaphore,
                                                    Executive,
                                                    KernelMode,
                                                    FALSE,
                                                    &Timeout);
 
        if (waitStatus == STATUS_TIMEOUT)
        {
            DPRINT1("HDA_SendVerbs: timeout! Queued: %u\n", Queued);
            return STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    if (Responses != NULL) {
        memcpy(Responses, Codec->Responses, Codec->ResponseCount * sizeof(ULONG));
    }
 
    return STATUS_SUCCESS;
}

Referenced by HDA_InitCodec(), and HDA_TransferCodecVerbs().

Variable Documentation

HDA_DpcForIsr

IO_DPC_ROUTINE HDA_DpcForIsr

Definition at line 119 of file hdaudbus.h.

Referenced by HDA_AddDevice().

HDA_InterruptService

KSERVICE_ROUTINE HDA_InterruptService

Definition at line 118 of file hdaudbus.h.

Referenced by HDA_FDOStartDevice().