prop.cpp

windows 底层驱动

                    break;
                case XUGUANG_126:
                    pCaps->MinFrequency = BAND_LOW_XG126;
                    pCaps->MaxFrequency = BAND_HIGH_XG126;
                    break;
                case TCL_2002_MI3:
                    pCaps->MinFrequency = BAND_LOW_TCL2002MI3;
                    pCaps->MaxFrequency = BAND_HIGH_TCL2002MI3;
					break;
                case PHILIPS_FMD1216_ME:
                    pCaps->MinFrequency = BAND_LOW_FMD1216ME;
                    pCaps->MaxFrequency = BAND_MAX_FMD1216ME;
                    break;
                default: 
                    pCaps->MinFrequency = BAND_LOW;
                    pCaps->MaxFrequency = BAND_HI;
                    break;
                }


                break;
            }

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_MODE_CAPS_S );

            break;
        }

        // tuner tuning process
        case KSPROPERTY_TUNER_STATUS:
        {
            PKSPROPERTY_TUNER_STATUS_S pStat = (PKSPROPERTY_TUNER_STATUS_S)pSPD->Property;
            pStat = PKSPROPERTY_TUNER_STATUS_S( pSPD->PropertyInfo );
            pStat->PLLOffset = TunerGetPllOffset( pSrb, &pStat->Busy );
            pStat->CurrentFrequency = pTunerDataExt->ulCurrentFrequency;
            pStat->SignalStrength = 0;

            if (pTunerDataExt->ulTunerMode == KSPROPERTY_TUNER_MODE_FM_RADIO)
            {
                if(pStat->PLLOffset == 0)
                    pStat->SignalStrength = 100;
            }


            // Workaround for lock detect, if we're in ATSC mode, and the NxtWave chip
            // is locked, return 100 for the signal strength, otherwise return zero.

            if (pTunerDataExt->ulTunerMode == KSPROPERTY_TUNER_MODE_ATSC)
            {
                BOOL bFrameLock = FALSE;
                NxtGetLockStatus( pTunerDataExt, &bFrameLock );

                if ( bFrameLock )
                {
                    DbgLogInfo(("Signal Strength = 100\n"));
                    pStat->SignalStrength = 100;
                }
                else
                {
                    DbgLogInfo(("Signal Strength = 0\n"));
                    pStat->SignalStrength = 0;
                }
            }
            pSrb->ActualBytesTransferred = sizeof(KSPROPERTY_TUNER_STATUS_S);

            break;
        }

        // tuning standard
        case KSPROPERTY_TUNER_STANDARD:
        {
            PKSPROPERTY_TUNER_STANDARD_S pStd = (PKSPROPERTY_TUNER_STANDARD_S)pSPD->Property;
            pStd = PKSPROPERTY_TUNER_STANDARD_S( pSPD->PropertyInfo );
            pStd->Standard = pTunerDataExt->ulStandard;
            pSrb->ActualBytesTransferred = sizeof(KSPROPERTY_TUNER_STANDARD_S);
            break;
        }

        // current tuner input no.
        case KSPROPERTY_TUNER_INPUT:
        {
            PKSPROPERTY_TUNER_INPUT_S pIn = (PKSPROPERTY_TUNER_INPUT_S)pSPD->Property;
            pIn = PKSPROPERTY_TUNER_INPUT_S( pSPD->PropertyInfo );
            pIn->InputIndex = pTunerDataExt->ulTunerInput;
            pSrb->ActualBytesTransferred = sizeof(KSPROPERTY_TUNER_INPUT_S);
            break;
        }

        case KSPROPERTY_TUNER_FREQUENCY:
        {
            PKSPROPERTY_TUNER_FREQUENCY_S pFreq = (PKSPROPERTY_TUNER_FREQUENCY_S)pSPD->PropertyInfo;
			pFreq->Frequency = pTunerDataExt->ulCurrentFrequency;
            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_FREQUENCY_S );
			break;
        }

        default:
            DbgLogWarn(( "AdapterGetTunerProperty( <other> 0x%08X )", pSrb->Command ));
            pSrb->Status = STATUS_NOT_IMPLEMENTED;
            break;
    }
}

/*++ ********************************************************************\
*
*   Function:
*
*       void AdapterSetTunerProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
*
*   Purpose:
*
*       Set the standard property value
*
*   Return:
*
*       None
*
*   History:
*
*
\******************************************************************** --*/
void
AdapterSetTunerProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
{
    PTUNER_DATA_EXTENSION pTunerDataExt = (PTUNER_DATA_EXTENSION)pSrb->HwDeviceExtension;
    PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
    PVOID pV = pSPD->PropertyInfo;

    //DbgLogTrace(("AdapterSetTunerProperty(%x))\n", pSrb));

    pSrb->Status = STATUS_SUCCESS; // assume success

    switch( pSPD->Property->Id )
    {
        case KSPROPERTY_TUNER_FREQUENCY:
        {
            PKSPROPERTY_TUNER_FREQUENCY_S pFreq = (PKSPROPERTY_TUNER_FREQUENCY_S)pV;
            DbgLog(("*** Country = %d (%02xh)\n", pFreq->Country, pFreq->Country));
            pTunerDataExt->country_code = pFreq->Country;
            if(pFreq->Frequency != pTunerDataExt->ulCurrentFrequency)
            {
                pTunerDataExt->Channel = pFreq->Channel;
                if ( !TunerSetFrequency( pTunerDataExt, pFreq->Frequency ) )
				{
					pSrb->Status = STATUS_UNSUCCESSFUL;
                }
            }
            break;
        }

        case KSPROPERTY_TUNER_MODE:
        {
            PKSPROPERTY_TUNER_MODE_S pMode = (PKSPROPERTY_TUNER_MODE_S)pV;

            // 13 May 2003 - If tuning to FM from TV on an MK3 tuner,
            //                   force a set to stable high-frequency TV channel first
            if ((pTunerDataExt->uiTunerType == PHILIPS_FM1216_MK3 ||
                 pTunerDataExt->uiTunerType == PHILIPS_FM1236_MK3 ||
                 pTunerDataExt->uiTunerType == PHILIPS_FMD1216_ME ||
                 pTunerDataExt->uiTunerType == PHILIPS_FM1286_MK3) &&
                (pTunerDataExt->ulTunerMode == KSPROPERTY_TUNER_MODE_TV) &&
                (pMode->Mode == KSPROPERTY_TUNER_MODE_FM_RADIO))
            {
                if ( !TunerSetFrequency( pTunerDataExt, 150000000 ) )
            	{
					pSrb->Status = STATUS_UNSUCCESSFUL;
                }
            }

            pTunerDataExt->ulTunerMode = pMode->Mode;
            TunerSetTunerMode( pTunerDataExt );
            break;
        }

        case KSPROPERTY_TUNER_STANDARD:
        {
            PKSPROPERTY_TUNER_STANDARD_S pStandard = (PKSPROPERTY_TUNER_STANDARD_S)pV;
            ULONG Standard = pStandard->Standard;
            TunerSetStandard( pSrb, Standard );
            break;
        }
        case KSPROPERTY_TUNER_INPUT:
        {
            PKSPROPERTY_TUNER_INPUT_S pIn = (PKSPROPERTY_TUNER_INPUT_S)pSPD->Property;
            pIn = PKSPROPERTY_TUNER_INPUT_S( pSPD->PropertyInfo );

            pTunerDataExt->ulTunerInput = pIn->InputIndex;
            TunerSetTunerInput( pSrb );
            break;
        }
        default:
            DbgLog(( "AdapterSetTunerProperty( <other> 0x%08X )", pSrb->Command ));
            pSrb->Status = STATUS_NOT_IMPLEMENTED;
            break;
    }

    if(pSrb->Status == STATUS_SUCCESS)
    {
        if(!pTunerDataExt->pHDALL_Device && !pTunerDataExt->bAttemptedToOpenHDALL)
        {
            GetHDAllDevice(&pTunerDataExt->pHDALL_Device, &pTunerDataExt->pHDALL_File);
            pTunerDataExt->bAttemptedToOpenHDALL = TRUE;
        }

        //If the request succeeded, notify HDALL of the change.
        if(pTunerDataExt->pHDALL_Device)
        {
            HDALL_INTERFACE Interface;
            Interface.Command = HDALL_COMMAND_NOTIFY;
            Interface.Data.NotificationInfo.TunerMode = pTunerDataExt->ulTunerMode;
            Interface.Data.NotificationInfo.Channel = pTunerDataExt->Channel;

            SendHDALLCommand(&Interface, pTunerDataExt->pHDALL_Device);
        }
    }

}

/*++ ********************************************************************\
*
*   Function:
*
*       void AdapterSetProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
*
*   Purpose:
*
*       Selects either standard, custom or shared custom
*       property to set
*
*   Return:
*
*       None
*
*   History:
*
*
\******************************************************************** --*/
VOID
AdapterSetProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
{
    PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;

    //DbgLogTrace(("AdapterSetProperty(%x))\n", pSrb));

    if ( IsEqualGUID( PROPSETID_TUNER, pSPD->Property->Set ))
    {
        AdapterSetTunerProperty( pSrb );
    }
    else
    {
        DbgLogWarn((0, "AdapterSetProperty unrecognized GUID: pSrb(%x), pSPD->Property->Set(%x)\n", pSrb, pSPD->Property->Set));
        pSrb->Status = STATUS_INVALID_PARAMETER;
    }
}

/*++ ********************************************************************\
*
*   Function:
*
*       void AdapterSetSharedCustomProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
*
*   Purpose:
*
*       Selects either standard, custom or shared custom
*       property to get
*
*   Return:
*
*       None
*
*   History:
*
*
\******************************************************************** --*/
VOID
AdapterGetProperty( PHW_STREAM_REQUEST_BLOCK pSrb )
{
    PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;

    //DbgLogTrace(("AdapterGetProperty(%x))\n", pSrb));

    if ( IsEqualGUID( PROPSETID_TUNER, pSPD->Property->Set ))
    {
        AdapterGetTunerProperty( pSrb );
    }
    else
    {
        DbgLogWarn((0, "AdapterGetProperty unrecognized GUID: pSrb(%x), pSPD->Property->Set(%x)\n", pSrb, pSPD->Property->Set));
        pSrb->Status = STATUS_INVALID_PARAMETER;
    }
}