CCMITopology Class Reference

#include <mintopo.hpp>

Inheritance diagram for CCMITopology:

Collaboration diagram for CCMITopology:

Public Member Functions
	DECLARE_STD_UNKNOWN ()
	DEFINE_STD_CONSTRUCTOR (CCMITopology)
	~CCMITopology ()
	STDMETHODIMP_ (NTSTATUS) loadMixerSettingsFromRegistry()
	STDMETHODIMP_ (NTSTATUS) storeMixerSettingsToRegistry()
	STDMETHODIMP_ (NTSTATUS) loadMixerSettingsFromMemory()
	STDMETHODIMP_ (NTSTATUS) storeMixerSettingsToMemory()
	STDMETHODIMP_ (NTSTATUS) GetDescription(OUT PPCFILTER_DESCRIPTOR *OutFilterDescriptor)
	STDMETHODIMP_ (NTSTATUS) DataRangeIntersection(IN ULONG PinId
	STDMETHODIMP_ (NTSTATUS) Init(IN PUNKNOWN UnknownAdapter

Static Public Member Functions
static NTSTATUS	EventHandler (PPCEVENT_REQUEST EventRequest)

Public Attributes
IN PKSDATARANGE	DataRange
IN PKSDATARANGE IN PKSDATARANGE	MatchingDataRange
IN PKSDATARANGE IN PKSDATARANGE IN ULONG	OutputBufferLength
IN PKSDATARANGE IN PKSDATARANGE IN ULONG OUT PVOID ResultantFormat	OPTIONAL
IN PKSDATARANGE IN PKSDATARANGE IN ULONG OUT PVOID ResultantFormat OUT PULONG	ResultantFormatLength
IN PRESOURCELIST	ResourceList
IN PRESOURCELIST IN PPORTTOPOLOGY	Port
Public Attributes inherited from CUnknown
union {
IUnknown   IUnknown
INonDelegatingUnknown   INonDelegatingUnknown
};
LONG	m_ref_count
PUNKNOWN	m_outer_unknown

Private Member Functions
NTSTATUS	ProcessResources (PRESOURCELIST ResourceList)

Private Attributes
PCMIADAPTER	CMIAdapter
CMI8738Info *	cm
UInt8	auxVolumeRegister
UInt8	micVolumeRegister
UInt8	mixer1Register
UInt8	mixer4Register
UInt32	functrl1Register
UInt32	chformatRegister
UInt32	legacyRegister
UInt32	miscctrlRegister
UInt32	NodeCache [2 *KSNODE_TOPO_INVALID]
UInt32	masterMuteDummy
BOOLEAN	settingsLoaded

Friends
NTSTATUS NTAPI	PropertyHandler_OnOff (PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	PropertyHandler_Level (PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	PropertyHandler_CpuResources (PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	PropertyHandler_ComponentId (PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	PropertyHandler_Private (PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	PropertyHandler_Mux (PPCPROPERTY_REQUEST PropertyRequest)

Detailed Description

Definition at line 34 of file mintopo.hpp.

Constructor & Destructor Documentation

~CCMITopology()

CCMITopology::~CCMITopology

(

)

Definition at line 71 of file mintopo.cpp.

{
    PAGED_CODE();

    DBGPRINT(("CCMITopology::~CCMITopology"));

    storeMixerSettingsToRegistry(); //or not. during system shutdown, this doesn't seem to work.
    cm->TopoMiniport = NULL;

    if (CMIAdapter) {
        CMIAdapter->Release();
    }
}

Member Function Documentation

DECLARE_STD_UNKNOWN()

CCMITopology::DECLARE_STD_UNKNOWN

(

)

DEFINE_STD_CONSTRUCTOR()

CCMITopology::DEFINE_STD_CONSTRUCTOR

(

CCMITopology

)

EventHandler()

static NTSTATUS CCMITopology::EventHandler ( PPCEVENT_REQUEST  EventRequest )

static

ProcessResources()

NTSTATUS CCMITopology::ProcessResources ( PRESOURCELIST  ResourceList )

private

STDMETHODIMP_() [1/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [2/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [3/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [4/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [5/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [6/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

STDMETHODIMP_() [7/7]

CCMITopology::STDMETHODIMP_

(

NTSTATUS

)

Friends And Related Function Documentation

PropertyHandler_ComponentId

NTSTATUS NTAPI PropertyHandler_ComponentId ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

Definition at line 1291 of file mintopo.cpp.

{
    PAGED_CODE();
    ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_ComponentId]"));

    NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
    CCMITopology *that = (CCMITopology *) ((PMINIPORTTOPOLOGY) PropertyRequest->MajorTarget);

    if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
        if (PropertyRequest->ValueSize >= sizeof(KSCOMPONENTID)) {
            PKSCOMPONENTID pComponentId = (PKSCOMPONENTID)PropertyRequest->Value;

            pComponentId->Manufacturer = MANUFACTURER_CM8738;
            pComponentId->Product      = PRODUCT_CM8738;
            pComponentId->Component    = COMPONENT_CM8738;
            pComponentId->Name         = GUID_NULL;
            pComponentId->Version      = CMIPCI_VERSION;
            pComponentId->Revision     = that->cm->chipVersion;

            PropertyRequest->ValueSize = sizeof(KSCOMPONENTID);
            ntStatus = STATUS_SUCCESS;
        } else if (PropertyRequest->ValueSize == 0) {
            PropertyRequest->ValueSize = sizeof(KSCOMPONENTID);
            ntStatus = STATUS_BUFFER_OVERFLOW;
        } else {
            PropertyRequest->ValueSize = 0;
            ntStatus = STATUS_BUFFER_TOO_SMALL;
        }
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        if (PropertyRequest->ValueSize >= sizeof(ULONG)) {
            PULONG AccessFlags = PULONG(PropertyRequest->Value);

            *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_GET;

            PropertyRequest->ValueSize = sizeof(ULONG);
            ntStatus = STATUS_SUCCESS;
        } else {
            PropertyRequest->ValueSize = 0;
            ntStatus = STATUS_BUFFER_TOO_SMALL;
        }
    }

    return ntStatus;
}

PropertyHandler_CpuResources

NTSTATUS NTAPI PropertyHandler_CpuResources ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

Definition at line 1239 of file mintopo.cpp.

{
    PAGED_CODE();
    ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_CpuResources]"));

    NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;

    if (PropertyRequest->Node == (ULONG)-1) {
        return ntStatus;
    }
    if (PropertyRequest->Node >= KSNODE_TOPO_INVALID) {
        return ntStatus;
    }

    if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
        if (PropertyRequest->ValueSize >= sizeof(LONG)) {
            *((PLONG)PropertyRequest->Value) = KSAUDIO_CPU_RESOURCES_NOT_HOST_CPU;

            PropertyRequest->ValueSize = sizeof(LONG);
            ntStatus = STATUS_SUCCESS;
        } else  {
            ntStatus = STATUS_BUFFER_TOO_SMALL;
        }
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        if (PropertyRequest->ValueSize >= (sizeof(KSPROPERTY_DESCRIPTION))) {
            PKSPROPERTY_DESCRIPTION PropDesc = PKSPROPERTY_DESCRIPTION(PropertyRequest->Value);

            PropDesc->AccessFlags       = KSPROPERTY_TYPE_BASICSUPPORT |
                                          KSPROPERTY_TYPE_GET;
            PropDesc->DescriptionSize   = sizeof(KSPROPERTY_DESCRIPTION);
            PropDesc->PropTypeSet.Set   = KSPROPTYPESETID_General;
            PropDesc->PropTypeSet.Id    = VT_I4;
            PropDesc->PropTypeSet.Flags = 0;
            PropDesc->MembersListCount  = 0;
            PropDesc->Reserved          = 0;

            PropertyRequest->ValueSize = sizeof(KSPROPERTY_DESCRIPTION);
            ntStatus = STATUS_SUCCESS;
        } else if (PropertyRequest->ValueSize >= sizeof(ULONG)) {
            PULONG AccessFlags = PULONG(PropertyRequest->Value);

            *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_GET;

            PropertyRequest->ValueSize = sizeof(ULONG);
            ntStatus = STATUS_SUCCESS;
        }
    }

    return ntStatus;
}

PropertyHandler_Level

NTSTATUS NTAPI PropertyHandler_Level ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

Definition at line 1101 of file mintopo.cpp.

{
    PAGED_CODE();
    ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_Level]"));

    CCMITopology *that = (CCMITopology *) ((PMINIPORTTOPOLOGY) PropertyRequest->MajorTarget);
    NTSTATUS     ntStatus = STATUS_INVALID_PARAMETER;
    UInt32       channel;
    UInt8        mixerValue;

    if ((PropertyRequest->Node == ULONG(-1)) || (PropertyRequest->Node >= KSNODE_TOPO_INVALID) || (PropertyRequest->PropertyItem->Id != KSPROPERTY_AUDIO_VOLUMELEVEL)) {
        return ntStatus;
    }

    if ( ((PropertyRequest->Verb & KSPROPERTY_TYPE_GET) || (PropertyRequest->Verb & KSPROPERTY_TYPE_SET)) && (PropertyRequest->InstanceSize >= sizeof(LONG)) ) {

        channel = *(PLONG(PropertyRequest->Instance));

        if ((PropertyRequest->Node == KSNODE_TOPO_MICOUT_VOLUME) && (channel != CHAN_LEFT)) {
            return STATUS_INVALID_PARAMETER;
        }

        if ( ( (channel == CHAN_LEFT) || (channel == CHAN_RIGHT) ) && (PropertyRequest->ValueSize >= sizeof(LONG))) {

            PLONG Level = (PLONG)PropertyRequest->Value;

            for (unsigned int i=0;i<SIZEOF_ARRAY(VolTable);i++)
            {
                if (VolTable[i].node == PropertyRequest->Node) {
                    if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {

                        mixerValue = (that->CMIAdapter->readMixer(VolTable[i].reg+channel) >> VolTable[i].shift) & VolTable[i].mask;
                        *Level     = that->NodeCache[(2*PropertyRequest->Node)+channel];

                        if (mixerValue != ((*Level >> (VolTable[i].dbshift+16))+VolTable[i].mask)) {
                            *Level = (mixerValue - VolTable[i].mask) << (16+VolTable[i].dbshift);
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                        }
                    } else
                    if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                        if (*Level <= (VolTable[i].min << 16)) {
                            mixerValue = 0;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = VolTable[i].min << 16;
                        } else
                        if (*Level >= (VolTable[i].max << 16)) {
                            mixerValue = VolTable[i].mask;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = VolTable[i].max << 16;
                        } else {
                            mixerValue = ((*Level >> (VolTable[i].dbshift+16)) + VolTable[i].mask) & VolTable[i].mask;
                            that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                        }
                        that->CMIAdapter->writeMixer(VolTable[i].reg+channel, mixerValue << VolTable[i].shift);
                    }
                    ntStatus = STATUS_SUCCESS;
                }
            }
            if (PropertyRequest->Node == KSNODE_TOPO_AUX_VOLUME) {
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                    mixerValue = that->auxVolumeRegister;
                    *Level     = that->NodeCache[(2*PropertyRequest->Node)+channel];
                    if (channel == CHAN_LEFT) {
                        mixerValue >>= 4;
                    }
                    mixerValue &= 0x0F;
                    if (mixerValue != ((*Level >> 18)+0x0F)) {
                        *Level = (mixerValue - 0x0F) << 18;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                    }
                } else
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                    if (*Level <= (-30 << 16)) {
                        mixerValue = 0;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = -30 << 16;
                    } else
                    if (*Level >= 0) {
                        mixerValue = 0x0F;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = 0;
                    } else  {
                        mixerValue = ((*Level >> 18) + 0x0F) & 0x0F;
                        that->NodeCache[(2*PropertyRequest->Node)+channel] = *Level;
                    }

                    if (channel == CHAN_RIGHT) {
                        that->auxVolumeRegister = (that->auxVolumeRegister & 0xF0) | mixerValue;
                    } else if (channel == CHAN_LEFT) {
                        that->auxVolumeRegister = (that->auxVolumeRegister & 0x0F) | (mixerValue << 4);
                    }
                    that->CMIAdapter->writeUInt8(REG_MIXER3, that->auxVolumeRegister);
                }
                ntStatus = STATUS_SUCCESS;
            }
            if ((PropertyRequest->Node == KSNODE_TOPO_MICIN_VOLUME) && (channel == CHAN_LEFT)) {
                if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                    *Level     = that->NodeCache[(2*PropertyRequest->Node)];
                    mixerValue = that->micVolumeRegister >> 1 & 0x7;
                    if (mixerValue != ((*Level >> 19)+0x07)) {
                        *Level = (mixerValue - 0x07) << 19;
                        that->NodeCache[(2*PropertyRequest->Node)] = *Level;
                    }
                } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                    if (*Level <= (-56 << 16)) {
                        mixerValue = 0;
                        that->NodeCache[(2*PropertyRequest->Node)] = -56 << 16;
                    } else if (*Level >= 0) {
                        mixerValue = 0x07;
                        that->NodeCache[(2*PropertyRequest->Node)] = 0;
                    } else {
                        mixerValue = ((*Level >> 19) + 0x07) & 0x07;
                        that->NodeCache[(2*PropertyRequest->Node)] = *Level;
                    }
                    that->micVolumeRegister &= ~(0x07 << 1);
                    that->micVolumeRegister |= mixerValue << 1;
                    that->CMIAdapter->writeUInt8(REG_MIXER2, that->micVolumeRegister);
                }
                ntStatus = STATUS_SUCCESS;
            }
            if ((NT_SUCCESS(ntStatus)) && (PropertyRequest->Verb & KSPROPERTY_TYPE_GET)) {
                PropertyRequest->ValueSize = sizeof(LONG);
            }
        }
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        switch(PropertyRequest->Node) {
            case KSNODE_TOPO_LINEOUT_VOLUME:
            case KSNODE_TOPO_WAVEOUT_VOLUME:
            case KSNODE_TOPO_CD_VOLUME:
            case KSNODE_TOPO_LINEIN_VOLUME:
            case KSNODE_TOPO_MICOUT_VOLUME:
            case KSNODE_TOPO_MICIN_VOLUME:
            case KSNODE_TOPO_AUX_VOLUME:
                ntStatus = BasicSupportHandler(PropertyRequest);
                break;
        }
    }

    return ntStatus;
}

PropertyHandler_Mux

NTSTATUS NTAPI PropertyHandler_Mux ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

PropertyHandler_OnOff

NTSTATUS NTAPI PropertyHandler_OnOff ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

Definition at line 480 of file mintopo.cpp.

{
    PAGED_CODE();
    ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_OnOff]"));

    CCMITopology *that = (CCMITopology *) ((PMINIPORTTOPOLOGY) PropertyRequest->MajorTarget);

    NTSTATUS  ntStatus = STATUS_INVALID_PARAMETER;
    UInt8     mask, reg;
    LONG      channel;

    if (PropertyRequest->Node == ULONG(-1)) {
        return ntStatus;
    }

    if ( ((PropertyRequest->Verb & KSPROPERTY_TYPE_GET) || (PropertyRequest->Verb & KSPROPERTY_TYPE_SET)) && (PropertyRequest->InstanceSize >= sizeof(LONG)) ) {
        channel = *(PLONG(PropertyRequest->Instance));
        if (PropertyRequest->ValueSize >= sizeof(BOOL)) {

            if (PropertyRequest->PropertyItem->Id == KSPROPERTY_AUDIO_MUTE) {
                PBOOL Muted = PBOOL(PropertyRequest->Value);
                switch (PropertyRequest->Node) {

                    case KSNODE_TOPO_WAVEOUT_MUTE:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = (that->CMIAdapter->readUInt8(REG_MIXER1) & MUTE_WAVE);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->setUInt8Bit(REG_MIXER1, MUTE_WAVE);
                            } else {
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER1, MUTE_WAVE);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_AUX_MUTE:
                        switch (channel) {
                            case CHAN_LEFT:  mask = MUTE_AUX_L; break;
                            case CHAN_RIGHT: mask = MUTE_AUX_R; break;
                            default: return ntStatus;
                        }

                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->micVolumeRegister & mask);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->micVolumeRegister &= ~mask;
                            } else {
                                that->micVolumeRegister |= mask;
                            }
                            that->CMIAdapter->writeUInt8(REG_MIXER2, that->micVolumeRegister);
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_MICOUT_MUTE:
                        if (channel != CHAN_LEFT) {
                            return ntStatus;
                        }

                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(SBREG_OUTPUTCTRL) & EN_MIC);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(SBREG_OUTPUTCTRL, EN_MIC);
                            } else {
                                that->CMIAdapter->setMixerBit(SBREG_OUTPUTCTRL, EN_MIC);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_CD_MUTE:
                        switch (channel) {
                            case CHAN_LEFT:  mask = EN_CD_L; break;
                            case CHAN_RIGHT: mask = EN_CD_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(SBREG_OUTPUTCTRL) & mask);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(SBREG_OUTPUTCTRL, mask);
                            } else {
                                that->CMIAdapter->setMixerBit(SBREG_OUTPUTCTRL, mask);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_LINEIN_MUTE:
                        switch (channel) {
                            case CHAN_LEFT:  mask = EN_LINEIN_L; break;
                            case CHAN_RIGHT: mask = EN_LINEIN_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(SBREG_OUTPUTCTRL) & mask);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(SBREG_OUTPUTCTRL, mask);
                            } else {
                                that->CMIAdapter->setMixerBit(SBREG_OUTPUTCTRL, mask);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_MIC_MUTE_IN:
                        if (channel != CHAN_LEFT) {
                            return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(SBREG_IN_CTRL_L) & EN_MIC);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(SBREG_IN_CTRL_L, EN_MIC);
                                that->CMIAdapter->clearMixerBit(SBREG_IN_CTRL_R, EN_MIC);
                            } else {
                                that->CMIAdapter->setMixerBit(SBREG_IN_CTRL_L, EN_MIC);
                                that->CMIAdapter->setMixerBit(SBREG_IN_CTRL_R, EN_MIC);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_CD_MUTE_IN:
                        switch (channel) {
                            case CHAN_LEFT:  mask = EN_CD_L; reg = SBREG_IN_CTRL_L; break;
                            case CHAN_RIGHT: mask = EN_CD_R; reg = SBREG_IN_CTRL_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(reg) & mask);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(reg, mask);
                            } else {
                                that->CMIAdapter->setMixerBit(reg, mask);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_LINEIN_MUTE_IN:
                        switch (channel) {
                            case CHAN_LEFT:  mask = EN_LINEIN_L; reg = SBREG_IN_CTRL_L; break;
                            case CHAN_RIGHT: mask = EN_LINEIN_R; reg = SBREG_IN_CTRL_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->CMIAdapter->readMixer(reg) & mask);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->CMIAdapter->clearMixerBit(reg, mask);
                            } else {
                                that->CMIAdapter->setMixerBit(reg, mask);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;


                    case KSNODE_TOPO_AUX_MUTE_IN:
                        switch (channel) {
                            case CHAN_LEFT:  mask = MUTE_RAUX_L; break;
                            case CHAN_RIGHT: mask = MUTE_RAUX_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = !(that->micVolumeRegister & mask) ;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->micVolumeRegister &= ~mask;
                            } else {
                                that->micVolumeRegister |= mask;
                            }
                            that->CMIAdapter->writeUInt8(REG_MIXER2, that->micVolumeRegister);
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_WAVEOUT_MUTE_IN:
                        switch (channel) {
                            case CHAN_LEFT:  mask = EN_WAVEIN_L; break;
                            case CHAN_RIGHT: mask = EN_WAVEIN_R; break;
                            default: return ntStatus;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
//                          *Muted = !(that->CMIAdapter->readUInt8(REG_MIXER1) & mask);
                            *Muted = !(that->cm->enableSPDIFIn);
                            ntStatus = STATUS_SUCCESS;
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*Muted) {
                                that->cm->enableSPDIFIn = FALSE;
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER1, mask);
                            } else {
                                that->cm->enableSPDIFIn = TRUE;
                                that->CMIAdapter->setUInt8Bit(REG_MIXER1, mask);
                            }
                            ntStatus = STATUS_SUCCESS;
                        }
                        break;

                    case KSNODE_TOPO_MASTER_MUTE_DUMMY:
                        channel = (1 << channel);
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *Muted = that->masterMuteDummy & channel;
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*Muted) {
                                that->masterMuteDummy |= channel;
                            } else {
                                that->masterMuteDummy &= ~channel;
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;
                }
            }

            if (PropertyRequest->PropertyItem->Id == KSPROPERTY_AUDIO_LOUDNESS) {
                PBOOL LoudnessOn = PBOOL(PropertyRequest->Value);
                switch  (PropertyRequest->Node) {
                    case KSNODE_TOPO_MICIN_LOUDNESS:
                        if (channel == CHAN_LEFT) {
                            if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                                *LoudnessOn = (that->CMIAdapter->readMixer(SBREG_EXTENSION) & EN_MICBOOST);
                            }
                            if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                                if (*LoudnessOn) {
                                    that->CMIAdapter->setMixerBit(SBREG_EXTENSION, EN_MICBOOST);
                                } else {
                                    that->CMIAdapter->clearMixerBit(SBREG_EXTENSION, EN_MICBOOST);
                                }
                            }
                            ntStatus = STATUS_SUCCESS;
                        }
                        break;
                    case KSNODE_TOPO_MICOUT_LOUDNESS:
                        if (channel == CHAN_LEFT) {
                            if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                                *LoudnessOn = !(that->CMIAdapter->readUInt8(REG_MIXER2) & DIS_MICGAIN);
                            }
                            if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                                if (*LoudnessOn) {
                                    that->CMIAdapter->clearUInt8Bit(REG_MIXER2, DIS_MICGAIN);
                                } else {
                                    that->CMIAdapter->setUInt8Bit(REG_MIXER2, DIS_MICGAIN);
                                }
                            }
                            ntStatus = STATUS_SUCCESS;
                        }
                        break;
                    case KSNODE_TOPO_IEC_5V:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_MISCCTRL) & EN_SPDO5V);
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_MISCCTRL, EN_SPDO5V);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_MISCCTRL, EN_SPDO5V);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;
                    case KSNODE_TOPO_IEC_OUT:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            if (that->cm) {
                                *LoudnessOn = that->cm->enableSPDIFOut;
                            }
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (that->cm) {
                                that->cm->enableSPDIFOut = (*LoudnessOn);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_INVERSE:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            if (that->cm->chipVersion <= 37) {
                                *LoudnessOn = (that->CMIAdapter->readUInt8(REG_MIXER4) & INV_SPDIFI1);
                            } else {
                                *LoudnessOn = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & INV_SPDIFI2);
                            }
                        }
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
                            if (*LoudnessOn) {
                                if (that->cm->chipVersion <= 37) {
                                    that->CMIAdapter->setUInt8Bit(REG_MIXER4, INV_SPDIFI1);
                                } else {
                                    that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, INV_SPDIFI2);
                                }
                            } else {
                                if (that->cm->chipVersion <= 37) {
                                    that->CMIAdapter->clearUInt8Bit(REG_MIXER4, INV_SPDIFI1);
                                } else {
                                    that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, INV_SPDIFI2);
                                }
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_MONITOR:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt8(REG_MIXER1) & EN_SPDI2DAC);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt8Bit(REG_MIXER1, EN_SPDI2DAC);
                            } else {
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER1, EN_SPDI2DAC);
                            }
                            if (that->cm) {
                                that->cm->enableSPDIFInMonitor = *LoudnessOn;
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_SELECT:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            if (that->cm->chipVersion <= 37) {
                                *LoudnessOn = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & SEL_SPDIFI1);
                            } else {
                                *LoudnessOn = (that->CMIAdapter->readUInt32(REG_MISCCTRL) & SEL_SPDIFI2);
                            }
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                if (that->cm->chipVersion <= 37) {
                                    that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, SEL_SPDIFI1);
                                } else {
                                    that->CMIAdapter->setUInt32Bit(REG_MISCCTRL, SEL_SPDIFI2);
                                }
                            } else {
                                if (that->cm->chipVersion <= 37) {
                                    that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, SEL_SPDIFI1);
                                } else {
                                    that->CMIAdapter->clearUInt32Bit(REG_MISCCTRL, SEL_SPDIFI2);
                                }
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_XCHG_FB:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt8(REG_MIXER1) & REAR2FRONT);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt8Bit(REG_MIXER1, REAR2FRONT);
                            } else {
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER1, REAR2FRONT);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_BASS2LINE:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_LEGACY) & BASS2LINE);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_LEGACY, BASS2LINE);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_LEGACY, BASS2LINE);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_CENTER2LINE:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_LEGACY) & CENTER2LINE);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_LEGACY, CENTER2LINE);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_LEGACY, CENTER2LINE);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_COPYRIGHT:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_LEGACY) & EN_SPDCOPYRHT);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_LEGACY, EN_SPDCOPYRHT);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_LEGACY, EN_SPDCOPYRHT);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_POLVALID:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & POLVALID);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, POLVALID);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, POLVALID);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_IEC_LOOP:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt32(REG_FUNCTRL1) & LOOP_SPDF);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt32Bit(REG_FUNCTRL1, LOOP_SPDF);
                            } else {
                                that->CMIAdapter->clearUInt32Bit(REG_FUNCTRL1, LOOP_SPDF);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_REAR2LINE:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt8(REG_MIXER1) & REAR2LINE);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt8Bit(REG_MIXER1, REAR2LINE);
                            } else {
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER1, REAR2LINE);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;

                    case KSNODE_TOPO_CENTER2MIC:
                        if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
                            *LoudnessOn = (that->CMIAdapter->readUInt8(REG_MIXER4) & CENTER2MIC) && (that->cm->chipVersion > 37);
                        }
                        if ((PropertyRequest->Verb & KSPROPERTY_TYPE_SET) && !(that->settingsLoaded) && (that->cm->chipVersion > 37)) {
                            if (*LoudnessOn) {
                                that->CMIAdapter->setUInt8Bit(REG_MIXER4, CENTER2MIC);
                            } else {
                                that->CMIAdapter->clearUInt8Bit(REG_MIXER4, CENTER2MIC);
                            }
                        }
                        ntStatus = STATUS_SUCCESS;
                        break;
                }
            }

            if ((NT_SUCCESS(ntStatus)) && (PropertyRequest->Verb & KSPROPERTY_TYPE_GET)) {
                PropertyRequest->ValueSize = sizeof(BOOL);
            }

        }
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        bool supported = false;
        if (PropertyRequest->PropertyItem->Id == KSPROPERTY_AUDIO_MUTE) {
            switch (PropertyRequest->Node) {
                case KSNODE_TOPO_CD_MUTE:
                case KSNODE_TOPO_LINEIN_MUTE:
                case KSNODE_TOPO_MICOUT_MUTE:
                case KSNODE_TOPO_AUX_MUTE:
                case KSNODE_TOPO_WAVEOUT_MUTE:
                case KSNODE_TOPO_LINEIN_MUTE_IN:
                case KSNODE_TOPO_MIC_MUTE_IN:
                case KSNODE_TOPO_CD_MUTE_IN:
                case KSNODE_TOPO_AUX_MUTE_IN:
                case KSNODE_TOPO_WAVEOUT_MUTE_IN:
                case KSNODE_TOPO_MASTER_MUTE_DUMMY:
                    supported = true;
            }
        }

        if (PropertyRequest->PropertyItem->Id == KSPROPERTY_AUDIO_LOUDNESS) {
            switch (PropertyRequest->Node) {
                case KSNODE_TOPO_MICIN_LOUDNESS:
                case KSNODE_TOPO_MICOUT_LOUDNESS:
                case KSNODE_TOPO_IEC_5V:
                case KSNODE_TOPO_IEC_OUT:
                case KSNODE_TOPO_IEC_INVERSE:
                case KSNODE_TOPO_IEC_MONITOR:
                case KSNODE_TOPO_IEC_SELECT:
                case KSNODE_TOPO_XCHG_FB:
                case KSNODE_TOPO_BASS2LINE:
                case KSNODE_TOPO_CENTER2LINE:
                case KSNODE_TOPO_IEC_COPYRIGHT:
                case KSNODE_TOPO_IEC_POLVALID:
                case KSNODE_TOPO_IEC_LOOP:
                case KSNODE_TOPO_REAR2LINE:
                    supported = true;
            }
            if ((PropertyRequest->Node == KSNODE_TOPO_CENTER2MIC) && (that->cm->chipVersion > 37)) {
                supported = true;
            }
        }

        if (supported) {
            if (PropertyRequest->ValueSize >= (sizeof(KSPROPERTY_DESCRIPTION))) {
                PKSPROPERTY_DESCRIPTION PropDesc = PKSPROPERTY_DESCRIPTION(PropertyRequest->Value);

                PropDesc->AccessFlags      = KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_BASICSUPPORT;
                PropDesc->DescriptionSize   = sizeof(KSPROPERTY_DESCRIPTION);
                PropDesc->PropTypeSet.Set   = KSPROPTYPESETID_General;
                PropDesc->PropTypeSet.Id    = VT_BOOL;
                PropDesc->PropTypeSet.Flags = 0;
                PropDesc->MembersListCount  = 0;
                PropDesc->Reserved        = 0;

                PropertyRequest->ValueSize = sizeof(KSPROPERTY_DESCRIPTION);
                ntStatus = STATUS_SUCCESS;
            } else if (PropertyRequest->ValueSize >= sizeof(ULONG)) {
                PULONG AccessFlags = PULONG(PropertyRequest->Value);

                *AccessFlags = KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_BASICSUPPORT;

                PropertyRequest->ValueSize = sizeof(ULONG);
                ntStatus = STATUS_SUCCESS;
            }
        }
    }

    return ntStatus;
}

PropertyHandler_Private

NTSTATUS NTAPI PropertyHandler_Private ( PPCPROPERTY_REQUEST  PropertyRequest )

friend

Definition at line 1337 of file mintopo.cpp.

{
    PAGED_CODE();
    ASSERT(PropertyRequest);
    DBGPRINT(("[PropertyHandler_Private]"));

    NTSTATUS     ntStatus = STATUS_INVALID_DEVICE_REQUEST;
    CCMITopology *that = (CCMITopology *) ((PMINIPORTTOPOLOGY) PropertyRequest->MajorTarget);

    if (PropertyRequest->Verb & KSPROPERTY_TYPE_GET) {
        if (PropertyRequest->PropertyItem->Id != KSPROPERTY_CMI_GET) {
            return STATUS_INVALID_DEVICE_REQUEST;
        }

        if (PropertyRequest->ValueSize == 0) {
            PropertyRequest->ValueSize = sizeof(CMIDATA);
            return STATUS_BUFFER_OVERFLOW;
        } else if (PropertyRequest->ValueSize < sizeof (CMIDATA)) {
            PropertyRequest->ValueSize = 0;
            return STATUS_BUFFER_TOO_SMALL;
        }

        CMIDATA* cmiData = (CMIDATA*)PropertyRequest->Value;
#ifdef WAVERT
        RtlStringCbPrintfA(cmiData->driverVersion, sizeof(cmiData->driverVersion), CMIVERSION "-WaveRT");
#else
        RtlStringCbPrintfA(cmiData->driverVersion, sizeof(cmiData->driverVersion), CMIVERSION);
#endif
        cmiData->hardwareRevision    = that->cm->chipVersion;
        cmiData->maxChannels         = that->cm->maxChannels;
        cmiData->IOBase              = (USHORT)((ULONG_PTR)that->cm->IOBase);
        cmiData->MPUBase             = (USHORT)((ULONG_PTR)that->cm->MPUBase);
        cmiData->enableSPDO          = that->cm->enableSPDIFOut;
        cmiData->enableSPDIMonitor   = that->cm->enableSPDIFInMonitor;
        cmiData->enableSPDI          = that->cm->enableSPDIFIn;
        cmiData->formatMask          = that->cm->formatMask;
        cmiData->exchangeFrontBack   = (that->CMIAdapter->readUInt8(REG_MIXER1) & REAR2FRONT);
        cmiData->enableSPDO5V        = (that->CMIAdapter->readUInt32(REG_MISCCTRL) & EN_SPDO5V);
        cmiData->enableBass2Line     = (that->CMIAdapter->readUInt32(REG_LEGACY) & BASS2LINE);
        cmiData->enableCenter2Line   = (that->CMIAdapter->readUInt32(REG_LEGACY) & CENTER2LINE);
        cmiData->enableRear2Line     = (that->CMIAdapter->readUInt8(REG_MIXER1) & REAR2LINE);
        cmiData->enableCenter2Mic    = (that->CMIAdapter->readUInt8(REG_MIXER4) & CENTER2MIC) && (that->cm->chipVersion > 37);
        cmiData->enableSPDOCopyright = (that->CMIAdapter->readUInt32(REG_LEGACY) & EN_SPDCOPYRHT);
        cmiData->invertValidBitSPDI  = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & POLVALID);
        cmiData->loopSPDI            = (that->CMIAdapter->readUInt32(REG_FUNCTRL1) & LOOP_SPDF);
        if (that->cm->chipVersion <= 37) {
            cmiData->select2ndSPDI   = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & SEL_SPDIFI1);
            cmiData->invertPhaseSPDI = (that->CMIAdapter->readUInt8(REG_MIXER4) & INV_SPDIFI1);
        } else {
            cmiData->select2ndSPDI   = (that->CMIAdapter->readUInt32(REG_MISCCTRL) & SEL_SPDIFI2);
            cmiData->invertPhaseSPDI = (that->CMIAdapter->readUInt32(REG_CHFORMAT) & INV_SPDIFI2);
        }

        PropertyRequest->ValueSize = sizeof(CMIDATA);
        ntStatus = STATUS_SUCCESS;
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET) {
        if (PropertyRequest->PropertyItem->Id != KSPROPERTY_CMI_SET) {
            return STATUS_INVALID_DEVICE_REQUEST;
        }

        if (PropertyRequest->ValueSize == 0) {
            PropertyRequest->ValueSize = sizeof(CMIDATA);
            return STATUS_BUFFER_OVERFLOW;
        } else if (PropertyRequest->ValueSize < sizeof (CMIDATA)) {
            PropertyRequest->ValueSize = 0;
            return STATUS_BUFFER_TOO_SMALL;
        }
        CMIDATA* cmiData = (CMIDATA*)PropertyRequest->Value;
        that->cm->enableSPDIFIn         = cmiData->enableSPDI;
        that->cm->enableSPDIFOut        = cmiData->enableSPDO;
        that->cm->formatMask            = cmiData->formatMask;
        that->cm->enableSPDIFInMonitor  = cmiData->enableSPDIMonitor;

        if (cmiData->enableSPDI) {
            that->CMIAdapter->setUInt8Bit(REG_MIXER1, EN_WAVEIN_L | EN_WAVEIN_R);
        } else {
            that->CMIAdapter->clearUInt8Bit(REG_MIXER1, EN_WAVEIN_L | EN_WAVEIN_R);
        }

        if (cmiData->exchangeFrontBack) {
            that->CMIAdapter->setUInt8Bit(REG_MIXER1, REAR2FRONT);
        } else {
            that->CMIAdapter->clearUInt8Bit(REG_MIXER1, REAR2FRONT);
        }
        if (cmiData->enableSPDO5V) {
            that->CMIAdapter->setUInt32Bit(REG_MISCCTRL, EN_SPDO5V);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_MISCCTRL, EN_SPDO5V);
        }
        if (cmiData->enableSPDIMonitor) {
            that->CMIAdapter->setUInt8Bit(REG_MIXER1, EN_SPDI2DAC);
        } else {
            that->CMIAdapter->clearUInt8Bit(REG_MIXER1, EN_SPDI2DAC);
        }
        if (cmiData->enableBass2Line) {
            that->CMIAdapter->setUInt32Bit(REG_LEGACY, BASS2LINE);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_LEGACY, BASS2LINE);
        }
        if (cmiData->enableCenter2Line) {
            that->CMIAdapter->setUInt32Bit(REG_LEGACY, CENTER2LINE);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_LEGACY, CENTER2LINE);
        }
        if (cmiData->enableRear2Line) {
            that->CMIAdapter->setUInt8Bit(REG_MIXER1, REAR2LINE);
        } else {
            that->CMIAdapter->clearUInt8Bit(REG_MIXER1, REAR2LINE);
        }
        if (that->cm->chipVersion > 37) {
            if (cmiData->enableCenter2Mic) {
                that->CMIAdapter->setUInt8Bit(REG_MIXER4, CENTER2MIC);
            } else {
                that->CMIAdapter->clearUInt8Bit(REG_MIXER4, CENTER2MIC);
            }
        }
        if (cmiData->enableSPDOCopyright) {
            that->CMIAdapter->setUInt32Bit(REG_LEGACY, EN_SPDCOPYRHT);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_LEGACY, EN_SPDCOPYRHT);
        }
        if (cmiData->invertValidBitSPDI) {
            that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, POLVALID);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, POLVALID);
        }
        if (cmiData->loopSPDI) {
            that->CMIAdapter->setUInt32Bit(REG_FUNCTRL1, LOOP_SPDF);
        } else {
            that->CMIAdapter->clearUInt32Bit(REG_FUNCTRL1, LOOP_SPDF);
        }
        if (cmiData->select2ndSPDI) {
            if (that->cm->chipVersion <= 37) {
                that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, SEL_SPDIFI1);
            } else {
                that->CMIAdapter->setUInt32Bit(REG_MISCCTRL, SEL_SPDIFI2);
            }
        } else {
            if (that->cm->chipVersion <= 37) {
                that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, SEL_SPDIFI1);
            } else {
                that->CMIAdapter->clearUInt32Bit(REG_MISCCTRL, SEL_SPDIFI2);
            }
        }
        if (cmiData->invertPhaseSPDI) {
            if (that->cm->chipVersion <= 37) {
                that->CMIAdapter->setUInt8Bit(REG_MIXER4, INV_SPDIFI1);
            } else {
                that->CMIAdapter->setUInt32Bit(REG_CHFORMAT, INV_SPDIFI2);
            }
        } else {
            if (that->cm->chipVersion <= 37) {
                that->CMIAdapter->clearUInt8Bit(REG_MIXER4, INV_SPDIFI1);
            } else {
                that->CMIAdapter->clearUInt32Bit(REG_CHFORMAT, INV_SPDIFI2);
            }
        }

        that->storeMixerSettingsToRegistry();

        ntStatus = STATUS_SUCCESS;
    } else if (PropertyRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT) {
        if (PropertyRequest->ValueSize >= sizeof(ULONG)) {
            PULONG AccessFlags = PULONG(PropertyRequest->Value);

            *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_GET | KSPROPERTY_TYPE_SET;

            PropertyRequest->ValueSize = sizeof(ULONG);
            ntStatus = STATUS_SUCCESS;
        } else {
            PropertyRequest->ValueSize = 0;
            ntStatus = STATUS_BUFFER_TOO_SMALL;
        }
    }

    return ntStatus;
}

Member Data Documentation

auxVolumeRegister

UInt8 CCMITopology::auxVolumeRegister

private

Definition at line 40 of file mintopo.hpp.

Referenced by PropertyHandler_Level().

chformatRegister

UInt32 CCMITopology::chformatRegister

private

Definition at line 41 of file mintopo.hpp.

cm

CMI8738Info* CCMITopology::cm

private

Definition at line 39 of file mintopo.hpp.

Referenced by PropertyHandler_ComponentId(), PropertyHandler_OnOff(), PropertyHandler_Private(), and ~CCMITopology().

CMIAdapter

PCMIADAPTER CCMITopology::CMIAdapter

private

Definition at line 38 of file mintopo.hpp.

Referenced by PropertyHandler_Level(), PropertyHandler_OnOff(), PropertyHandler_Private(), and ~CCMITopology().

DataRange

IN PKSDATARANGE CCMITopology::DataRange

Definition at line 64 of file mintopo.hpp.

functrl1Register

UInt32 CCMITopology::functrl1Register

private

Definition at line 41 of file mintopo.hpp.

legacyRegister

UInt32 CCMITopology::legacyRegister

private

Definition at line 41 of file mintopo.hpp.

masterMuteDummy

UInt32 CCMITopology::masterMuteDummy

private

Definition at line 43 of file mintopo.hpp.

Referenced by PropertyHandler_OnOff().

MatchingDataRange

IN PKSDATARANGE IN PKSDATARANGE CCMITopology::MatchingDataRange

Definition at line 64 of file mintopo.hpp.

micVolumeRegister

UInt8 CCMITopology::micVolumeRegister

private

Definition at line 40 of file mintopo.hpp.

Referenced by PropertyHandler_Level(), and PropertyHandler_OnOff().

miscctrlRegister

UInt32 CCMITopology::miscctrlRegister

private

Definition at line 41 of file mintopo.hpp.

mixer1Register

UInt8 CCMITopology::mixer1Register

private

Definition at line 40 of file mintopo.hpp.

mixer4Register

UInt8 CCMITopology::mixer4Register

private

Definition at line 40 of file mintopo.hpp.

NodeCache

UInt32 CCMITopology::NodeCache[2 *KSNODE_TOPO_INVALID]

private

Definition at line 42 of file mintopo.hpp.

Referenced by PropertyHandler_Level().

OPTIONAL

IN PKSDATARANGE IN PKSDATARANGE IN ULONG OUT PVOID ResultantFormat CCMITopology::OPTIONAL

Definition at line 64 of file mintopo.hpp.

OutputBufferLength

IN PKSDATARANGE IN PKSDATARANGE IN ULONG CCMITopology::OutputBufferLength

Definition at line 64 of file mintopo.hpp.

Port

IN PRESOURCELIST IN PPORTTOPOLOGY CCMITopology::Port

Definition at line 77 of file mintopo.hpp.

ResourceList

IN PRESOURCELIST CCMITopology::ResourceList

Definition at line 77 of file mintopo.hpp.

ResultantFormatLength

IN PKSDATARANGE IN PKSDATARANGE IN ULONG OUT PVOID ResultantFormat OUT PULONG CCMITopology::ResultantFormatLength

Initial value:

{
        return STATUS_NOT_IMPLEMENTED

Definition at line 70 of file mintopo.hpp.

settingsLoaded

BOOLEAN CCMITopology::settingsLoaded

private

Definition at line 44 of file mintopo.hpp.

Referenced by PropertyHandler_OnOff().

---

The documentation for this class was generated from the following files:

• drivers/wdm/audio/drivers/CMIDriver/mintopo.hpp
• drivers/wdm/audio/drivers/CMIDriver/mintopo.cpp