mintopo.cpp

winddk src目录下的WDM源码压缩!

                        // if return buffer can hold a ULONG, return the access flags
                        PULONG AccessFlags = PULONG(PropertyRequest->Value);
                
                        *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT |
                                       KSPROPERTY_TYPE_GET |
                                       KSPROPERTY_TYPE_SET;
                
                        // set the return value size
                        PropertyRequest->ValueSize = sizeof(ULONG);
                        ntStatus = STATUS_SUCCESS;                    
                    }
                    break;
            }
        }
    }

    return ntStatus;
}

/*****************************************************************************
 * PropertyHandler_CpuResources()
 *****************************************************************************
 * Processes a KSPROPERTY_AUDIO_CPU_RESOURCES request
 */
static
NTSTATUS
PropertyHandler_CpuResources
(
    IN      PPCPROPERTY_REQUEST   PropertyRequest
)
{
    PAGED_CODE();

    ASSERT(PropertyRequest);

    _DbgPrintF(DEBUGLVL_VERBOSE,("[PropertyHandler_CpuResources]"));

    NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;

    // validate node
    if(PropertyRequest->Node != ULONG(-1))
    {
        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)))
            {
                // if return buffer can hold a KSPROPERTY_DESCRIPTION, return it
                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;

                // set the return value size
                PropertyRequest->ValueSize = sizeof(KSPROPERTY_DESCRIPTION);
                ntStatus = STATUS_SUCCESS;
            } else if(PropertyRequest->ValueSize >= sizeof(ULONG))
            {
                // if return buffer can hold a ULONG, return the access flags
                PULONG AccessFlags = PULONG(PropertyRequest->Value);
        
                *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT |
                               KSPROPERTY_TYPE_GET |
                               KSPROPERTY_TYPE_SET;
        
                // set the return value size
                PropertyRequest->ValueSize = sizeof(ULONG);
                ntStatus = STATUS_SUCCESS;                    
            }
        }
    }

    return ntStatus;
}

/*****************************************************************************
 * PropertyHandler_ComponentId()
 *****************************************************************************
 * Processes a KSPROPERTY_GENERAL_COMPONENTID request
 */
NTSTATUS
PropertyHandler_ComponentId
(
    IN      PPCPROPERTY_REQUEST   PropertyRequest
)
{
    PAGED_CODE();

    ASSERT(PropertyRequest);

    _DbgPrintF(DEBUGLVL_VERBOSE,("[PropertyHandler_ComponentId]"));

    NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;

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

            INIT_MMREG_MID(&pComponentId->Manufacturer, MM_MICROSOFT);
            pComponentId->Product   = PID_MSSB16;
            pComponentId->Name      = NAME_MSSB16;
            pComponentId->Component = GUID_NULL; // Not used for extended caps.
            pComponentId->Version   = MSSB16_VERSION;
            pComponentId->Revision  = MSSB16_REVISION;
            
            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))
        {
            // if return buffer can hold a ULONG, return the access flags
            PULONG AccessFlags = PULONG(PropertyRequest->Value);
    
            *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT |
                           KSPROPERTY_TYPE_GET;
    
            // set the return value size
            PropertyRequest->ValueSize = sizeof(ULONG);
            ntStatus = STATUS_SUCCESS;                    
        } else
        {
            PropertyRequest->ValueSize = 0;
            ntStatus = STATUS_BUFFER_TOO_SMALL;
        }
    }

    return ntStatus;
}

/*****************************************************************************
 * ThisManyOnes()
 *****************************************************************************
 * Returns a byte with the indicated number of ones in the low end.
 */
inline
BYTE
ThisManyOnes
(
    IN      BYTE Ones
)
{
    return ~(BYTE(0xff) << Ones);
}

/*****************************************************************************
 * CMiniportTopologySB16::ReadBitsFromMixer()
 *****************************************************************************
 * Reads specified bits from a mixer register.
 */
BYTE
CMiniportTopologySB16::
ReadBitsFromMixer
(
    BYTE Reg,
    BYTE Bits,
    BYTE Shift
)
{
    BYTE data = AdapterCommon->MixerRegRead(Reg);

    return( data >> Shift) & ThisManyOnes(Bits);
}

/*****************************************************************************
 * CMiniportTopologySB16::WriteBitsToMixer()
 *****************************************************************************
 * Writes specified bits to a mixer register.
 */
void
CMiniportTopologySB16::
WriteBitsToMixer
(
    BYTE Reg,
    BYTE Bits,
    BYTE Shift,
    BYTE Value
)
{
    BYTE mask = ThisManyOnes(Bits) << Shift;
    BYTE data = AdapterCommon->MixerRegRead(Reg);

    if(Reg < DSP_MIX_MAXREGS)
    {
        AdapterCommon->MixerRegWrite( Reg,
                                      (data & ~mask) | ( (Value << Shift) & mask));
    }
}
#ifdef EVENT_SUPPORT
#pragma code_seg()
/*****************************************************************************
 * CMiniportTopologySB16::EventHandler
 *****************************************************************************
 * This is the generic event handler.
 */
NTSTATUS CMiniportTopologySB16::EventHandler
(
    IN      PPCEVENT_REQUEST      EventRequest
)
{
    PAGED_CODE();

    ASSERT(EventRequest);

    _DbgPrintF (DEBUGLVL_VERBOSE, ("CMiniportTopologyICH::EventHandler"));

    // The major target is the object pointer to the topology miniport.
    CMiniportTopologySB16 *that =
        (CMiniportTopologySB16 *)(PMINIPORTTOPOLOGY(EventRequest->MajorTarget));

    ASSERT (that);

    // Validate the node.
    if (EventRequest->Node != LINEOUT_VOL)
        return STATUS_INVALID_PARAMETER;

    // What is to do?
    switch (EventRequest->Verb)
    {
        // Do we support event handling?!?
        case PCEVENT_VERB_SUPPORT:
            _DbgPrintF (DEBUGLVL_VERBOSE, ("BasicSupport Query for Event."));
            break;

        // We should add the event now!
        case PCEVENT_VERB_ADD:
            _DbgPrintF (DEBUGLVL_VERBOSE, ("Adding Event."));

            // If we have the interface and EventEntry is defined ...
            if ((EventRequest->EventEntry) && (that->PortEvents))
            {
                that->PortEvents->AddEventToEventList (EventRequest->EventEntry);
            }
            else
            {
                return STATUS_UNSUCCESSFUL;
            }
            break;

        case PCEVENT_VERB_REMOVE:
            // We cannot remove the event but we can stop generating the
            // events. However, it also doesn't hurt to always generate them ...
            _DbgPrintF (DEBUGLVL_VERBOSE, ("Removing Event."));
            break;

        default:
            return STATUS_INVALID_PARAMETER;
    }

    return STATUS_SUCCESS;
}

#pragma code_seg()
/*****************************************************************************
 * CMiniportTopologySB16::ServiceEvent()
 *****************************************************************************
 * This routine is called by the ISR to handle the event (volume) interrupt.
 */
STDMETHODIMP_(void) CMiniportTopologySB16::ServiceEvent (void)
{
    //
    // Generate an event for the master volume (as an example)
    //
    if (PortEvents)
    {
        PortEvents->GenerateEventList (NULL, KSEVENT_CONTROL_CHANGE,
                                         FALSE, ULONG(-1), TRUE,
                                         LINEOUT_VOL);
    }
}
#endif  // EVENT_SUPPORT