hdac_controller.h File Reference

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

Go to the source code of this file.

Classes
struct	_HDA_ASYNC_CONTEXT

Typedefs
typedef struct _HDA_ASYNC_CONTEXT	HDA_ASYNC_CONTEXT
typedef struct _HDA_ASYNC_CONTEXT *	PHDA_ASYNC_CONTEXT

Functions
	WDF_DECLARE_CONTEXT_TYPE_WITH_NAME (HDA_ASYNC_CONTEXT, HDAAsyncWorkItem_GetContext)
NTSTATUS	GetHDACapabilities (PFDO_CONTEXT fdoCtx)
NTSTATUS	StartHDAController (PFDO_CONTEXT fdoCtx)
NTSTATUS	StopHDAController (PFDO_CONTEXT fdoCtx)
NTSTATUS	SendHDACmds (PFDO_CONTEXT fdoCtx, ULONG count, PHDAUDIO_CODEC_TRANSFER CodecTransfer)
NTSTATUS	RunSingleHDACmd (PFDO_CONTEXT fdoCtx, ULONG val, ULONG *res)
BOOLEAN NTAPI	hda_interrupt (WDFINTERRUPT Interrupt, ULONG MessageID)
void NTAPI	hda_dpc (WDFINTERRUPT Interrupt, WDFOBJECT AssociatedObject)

Typedef Documentation

HDA_ASYNC_CONTEXT

typedef struct _HDA_ASYNC_CONTEXT HDA_ASYNC_CONTEXT

PHDA_ASYNC_CONTEXT

typedef struct _HDA_ASYNC_CONTEXT * PHDA_ASYNC_CONTEXT

Function Documentation

GetHDACapabilities()

NTSTATUS GetHDACapabilities

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 72 of file hdac_controller.cpp.

                                                 {
    UINT16 gcap = hda_read16(fdoCtx, GCAP);
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "chipset global capabilities = 0x%x\n", gcap);
 
    fdoCtx->is64BitOK = !!(gcap & 0x1);
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "64 bit OK? %d\n", fdoCtx->is64BitOK);
 
    fdoCtx->hwVersion = (hda_read8(fdoCtx, VMAJ) << 8) | hda_read8(fdoCtx, VMIN);
 
    fdoCtx->captureStreams = (gcap >> 8) & 0x0f;
    fdoCtx->playbackStreams = (gcap >> 12) & 0x0f;
 
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "streams (cap %d, playback %d)\n", fdoCtx->captureStreams, fdoCtx->playbackStreams);
 
    fdoCtx->captureIndexOff = 0;
    fdoCtx->playbackIndexOff = fdoCtx->captureStreams;
    fdoCtx->numStreams = fdoCtx->captureStreams + fdoCtx->playbackStreams;
 
    UINT8 corbSize = hda_read8(fdoCtx, CORBSIZE);
    if (!(corbSize & 0x40)) {
        return STATUS_DEVICE_FEATURE_NOT_SUPPORTED; //CORB must support 256
    }
 
    UINT8 rirbSize = hda_read8(fdoCtx, RIRBSIZE);
    if (!(rirbSize & 0x40)) {
        return STATUS_DEVICE_FEATURE_NOT_SUPPORTED; //RIRB must support 256
    }
 
    return STATUS_SUCCESS;
}

Referenced by Fdo_EvtDevicePrepareHardware().

hda_dpc()

void NTAPI hda_dpc	(	WDFINTERRUPT	Interrupt,
		WDFOBJECT	AssociatedObject
	)

Definition at line 415 of file hdac_controller.cpp.

  {
    UNREFERENCED_PARAMETER(AssociatedObject);
 
    WDFDEVICE Device = WdfInterruptGetDevice(Interrupt);
    PFDO_CONTEXT fdoCtx = Fdo_GetContext(Device);
 
    for (UINT32 i = 0; i < fdoCtx->numStreams; i++) {
        PHDAC_STREAM stream = &fdoCtx->streams[i];
        if (stream->irqReceived) {
            stream->irqReceived = FALSE;
 
            for (int j = 0; j < MAX_NOTIF_EVENTS; j++) {
                if (stream->registeredCallbacks[j].InUse) {
                    LARGE_INTEGER unknownVal = { 0 };
                    KeQuerySystemTime(&unknownVal);
                    stream->registeredCallbacks[j].NotificationCallback(stream->registeredCallbacks[j].CallbackContext, unknownVal);
                }
            }
 
            for (int j = 0; j < MAX_NOTIF_EVENTS; j++) {
                if (stream->registeredEvents[j]) {
                    KeSetEvent(stream->registeredEvents[j], IO_NO_INCREMENT, FALSE);
                }
            }
        }
    }
 
    if (fdoCtx->processRirb) {
        fdoCtx->processRirb = FALSE;
        HDAFlushRIRB(fdoCtx);
    }
}

Referenced by Fdo_Initialize().

hda_interrupt()

BOOLEAN NTAPI hda_interrupt	(	WDFINTERRUPT	Interrupt,
		ULONG	MessageID
	)

Definition at line 374 of file hdac_controller.cpp.

                     {
    UNREFERENCED_PARAMETER(MessageID);
 
    WDFDEVICE Device = WdfInterruptGetDevice(Interrupt);
    PFDO_CONTEXT fdoCtx = Fdo_GetContext(Device);
 
    BOOLEAN handled = FALSE;
 
    if (fdoCtx->dspInterruptCallback) {
        handled = (BOOLEAN)fdoCtx->dspInterruptCallback(fdoCtx->dspInterruptContext);
    }
 
    if (!fdoCtx->ControllerEnabled)
        return handled;
 
    UINT32 status = hda_read32(fdoCtx, INTSTS);
    if (status == 0 || status == 0xffffffff)
        return handled;
 
    handled = TRUE;
 
    if (hda_stream_interrupt(fdoCtx, status)) {
        WdfInterruptQueueDpcForIsr(Interrupt);
    }
 
    status = hda_read8(fdoCtx, RIRBSTS);
    if (status & RIRB_INT_MASK) {
        hda_write8(fdoCtx, RIRBSTS, RIRB_INT_MASK);
        if (status & RIRB_INT_RESPONSE) {
            fdoCtx->processRirb = TRUE;
            WdfInterruptQueueDpcForIsr(Interrupt);
        }
    }
 
    return handled;
}

Referenced by Fdo_Initialize().

RunSingleHDACmd()

NTSTATUS RunSingleHDACmd	(	PFDO_CONTEXT	fdoCtx,
		ULONG	val,
		ULONG *	res
	)

Definition at line 249 of file hdac_controller.cpp.

                                                                     {
    HDAUDIO_CODEC_TRANSFER transfer = { 0 };
    transfer.Output.Command = val;
 
    SklHdAudBusPrint(DEBUG_LEVEL_ERROR, DBG_IOCTL,
        "%s: Called. Command: 0x%x\n", __func__, val);
 
    NTSTATUS status = SendHDACmds(fdoCtx, 1, &transfer);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    UINT16 addr = HDACommandAddr(transfer.Output.Command);
    status = HDA_WaitForTransfer(fdoCtx, addr, 1, &transfer);
    if (transfer.Input.IsValid && res) {
        *res = transfer.Input.Response;
    }
    return status;
}

Referenced by Fdo_EnumerateCodec(), and Fdo_EvtDeviceD0EntryPostInterrupts().

SendHDACmds()

NTSTATUS SendHDACmds	(	PFDO_CONTEXT	fdoCtx,
		ULONG	count,
		PHDAUDIO_CODEC_TRANSFER	CodecTransfer
	)

Definition at line 207 of file hdac_controller.cpp.

                                                                                              {
    WdfInterruptAcquireLock(fdoCtx->Interrupt);
    for (ULONG i = 0; i < count; i++) {
        PHDAUDIO_CODEC_TRANSFER transfer = &CodecTransfer[i];
        RtlZeroMemory(&transfer->Input, sizeof(transfer->Input));
 
        UINT16 addr = HDACommandAddr(transfer->Output.Command);
 
        //Add command to corb
        UINT16 wp = hda_read16(fdoCtx, CORBWP);
        if (wp == 0xffff) {
            //Something wrong, controller likely went to sleep
            SklHdAudBusPrint(DEBUG_LEVEL_ERROR, DBG_IOCTL,
                "%s: device not found\n", __func__);
            WdfInterruptReleaseLock(fdoCtx->Interrupt);
            return STATUS_DEVICE_DOES_NOT_EXIST;
        }
 
        wp++;
        wp %= HDA_MAX_CORB_ENTRIES;
 
        UINT16 rp = hda_read16(fdoCtx, CORBRP);
        if (wp == rp) {
            //Oops it's full
            SklHdAudBusPrint(DEBUG_LEVEL_ERROR, DBG_IOCTL,
                "%s: device busy\n", __func__);
            WdfInterruptReleaseLock(fdoCtx->Interrupt);
            return STATUS_RETRY;
        }
 
        LONG oldVal = InterlockedIncrement(&fdoCtx->rirb.cmds[addr]);
        fdoCtx->rirb.xfer[addr].xfer[oldVal - 1] = transfer;
 
        fdoCtx->corb.buf[wp] = transfer->Output.Command;
 
        hda_write16(fdoCtx, CORBWP, wp);
    }
 
    WdfInterruptReleaseLock(fdoCtx->Interrupt);
    return STATUS_SUCCESS;
}

Referenced by HDA_TransferCodecVerbs(), and RunSingleHDACmd().

StartHDAController()

NTSTATUS StartHDAController

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 162 of file hdac_controller.cpp.

                                                 {
    NTSTATUS status;
    status = ResetHDAController(fdoCtx, TRUE);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    //Clear STATESTS
    hda_write16(fdoCtx, STATESTS, STATESTS_INT_MASK);
 
    HDAInitCorb(fdoCtx);
    HDAInitRirb(fdoCtx);
 
    HDAStartCorb(fdoCtx);
    HDAStartRirb(fdoCtx);
 
    //Enabling Controller Interrupt
    hda_write32(fdoCtx, GCTL, hda_read32(fdoCtx, GCTL) | HDA_GCTL_UNSOL);
    hda_write32(fdoCtx, INTCTL, hda_read32(fdoCtx, INTCTL) | HDA_INT_CTRL_EN | HDA_INT_GLOBAL_EN);
 
    {
    //Program position buffer
    PHYSICAL_ADDRESS posbufAddr = MmGetPhysicalAddress(fdoCtx->posbuf);
    hda_write32(fdoCtx, DPLBASE, posbufAddr.LowPart);
    hda_write32(fdoCtx, DPUBASE, posbufAddr.HighPart);
    }
 
    udelay(1000);
 
    fdoCtx->ControllerEnabled = TRUE;
 
exit:
    return status;
}

Referenced by Fdo_EvtDeviceD0Entry().

StopHDAController()

NTSTATUS StopHDAController

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 197 of file hdac_controller.cpp.

                                                {
    NTSTATUS status = ResetHDAController(fdoCtx, FALSE);
    fdoCtx->ControllerEnabled = FALSE;
    return status;
}

Referenced by Fdo_EvtDeviceD0Exit().

WDF_DECLARE_CONTEXT_TYPE_WITH_NAME()

WDF_DECLARE_CONTEXT_TYPE_WITH_NAME	(	HDA_ASYNC_CONTEXT	,
		HDAAsyncWorkItem_GetContext
	)