}        /* Process the next step based on the current scan status */        switch (Tuner_p->TunerInfo.Status)        {            /* "scanning" - we must process a new scan step */            case STTUNER_STATUS_SCANNING:                if (Tuner_p->ScanExact)                {                    Error = ProcessScanExact(Tuner_p, &Event);                    /* Since we are scanning for a single frequency,                     * unless we get the locked event we should treat                     * this as scan failed.                     */                    if (Event != STTUNER_EV_LOCKED)                        Event = STTUNER_EV_SCAN_FAILED;                }                else                {                    Error = ProcessNextScan(Tuner_p, &Event);                }                break;            /* In the "locked" case we have a frequency that we must attempt             * to maintain, or track.             */            case STTUNER_STATUS_LOCKED:                Error = ProcessTracking(Tuner_p, &Event);                /* Only process thresholds if the lock wasn't lost */                if (Event == STTUNER_EV_NO_OPERATION)                    Error = ProcessThresholds(Tuner_p, &Event);                break;            /* "not found" or "unlocked" cases require no further action.             * The scan task will have to wait for user intervention.             */            case STTUNER_STATUS_UNLOCKED:                /* Check the last status to ensure that the state hasn't                 * been changed externally e.g., scan aborted.                 */                if (Tuner_p->CurrentTunerInfo.Status == STTUNER_STATUS_SCANNING)                {                    Event = STTUNER_EV_SCAN_FAILED;                    break;                }                else if (Tuner_p->CurrentTunerInfo.Status == STTUNER_STATUS_LOCKED)                {                    Event = STTUNER_EV_UNLOCKED; /* Aborted scan */                    break;                }                /* Fall through */            case STTUNER_STATUS_NOT_FOUND:                /* Fall through */            default:                Event = STTUNER_EV_NO_OPERATION;                break;        }        /* If an error has occurred, then we must end the scan now -- we can't         * recover from this condition.         */        if (Error != TUNER_NO_ERROR)        {#ifdef STTUNER_DEBUG            Tuner_p->BusErrorCount++;            STTBX_Report((STTBX_REPORT_LEVEL_ERROR,                          "Bus error count = %u.\n",                          Tuner_p->BusErrorCount));#endif            /* In the event of a bus error -- we should tidy up the current             * task appropriately.             */            if (Tuner_p->TunerInfo.Status == STTUNER_STATUS_SCANNING)                Event = STTUNER_EV_SCAN_FAILED;            else if (Tuner_p->TunerInfo.Status == STTUNER_STATUS_LOCKED)                Event = STTUNER_EV_UNLOCKED;        }        /* Check the outcome of the last operation */        switch (Event)        {            case STTUNER_EV_LOCKED:     /* We are now locked */                Tuner_p->CurrentTunerInfo.Status = STTUNER_STATUS_LOCKED;                Tuner_p->ScanInfo.LockCount = NUMBER_LOST_BEFORE_UNLOCK;                /* Reset signal indicators */                Tuner_p->LastThreshold = ((U32)-1); /* Undefined threshold */                Tuner_p->LastSignal = ((U32)-1); /* Undefined signal */                break;            case STTUNER_EV_UNLOCKED:   /* We have lost lock */                Tuner_p->CurrentTunerInfo.Status = STTUNER_STATUS_UNLOCKED;                break;            case STTUNER_EV_SCAN_FAILED: /* The last scan failed */                /* The end of the scan list has been reached -- we drop                 * to the "not found" status.  A callback may be invoked                 * soon.                 */                Tuner_p->CurrentTunerInfo.Status = STTUNER_STATUS_NOT_FOUND;                LNBPowerDown(Tuner_p);  /* Power down the LNB */                break;            case STTUNER_EV_TIMEOUT:                /* If a timeout occurs, we do not allow the scan to continue.                 * this is effectively the same as reaching the end of the                 * scan list -- we reset our status to "not found".                 */                Tuner_p->CurrentTunerInfo.Status = STTUNER_STATUS_NOT_FOUND;                break;            case STTUNER_EV_SIGNAL_CHANGE:                /* No action required.  The event will be processed in the                 * call back below...                 */                break;            default:                /* We must now proceed to the next scan step, if there is                 * one -- if there isn't a next scan step then a callback                 * might be invoked.                 */                if (Tuner_p->TunerInfo.Status == STTUNER_STATUS_SCANNING &&                    Tuner_p->ScanInfo.ScanIndex < Tuner_p->ScanList.NumElements)                {                    /* Proceed to the next element.  In order to avoid a                     * spurious callback being invoked -- we reset the event                     * to a "no op".                     */                    Tuner_p->ScanInfo.Scan_p++;                    Tuner_p->ScanInfo.ScanIndex++;                    /* Avoid task delay */                    semaphore_signal(&Tuner_p->ScanTask.TimeoutSemaphore);                }                Tuner_p->CurrentTunerInfo.Status = Tuner_p->TunerInfo.Status;                break;        }        /* Commit new tuner information -- the API level can now see it */        Tuner_p->TunerInfo = Tuner_p->CurrentTunerInfo;        /* Critical section end */        semaphore_signal(&Tuner_p->ScanTask.GuardSemaphore);        /* We may have to generate an event if a notify function is setup */        if (Tuner_p->OpenParams.NotifyFunction != NULL &&            Event != STTUNER_EV_NO_OPERATION)        {            Tuner_p->OpenParams.NotifyFunction(Tuner_p->Handle, Event, Error);        }        else if (Event != STTUNER_EV_NO_OPERATION)        {            STTUNER_EvtParams_t EventInfo;            /* Use the event handler to notify */            EventInfo.Handle = Tuner_p->Handle;            EventInfo.Error = Error;            Error = STEVT_Notify(Tuner_p->EVTHandle,                                 Tuner_p->EvtId[EventToId(Event)],                                 &EventInfo);#ifdef STTUNER_DEBUG            if (Error != ST_NO_ERROR)            {                STTBX_Report((STTBX_REPORT_LEVEL_ERROR,                              "STEVT error = %u.\n",                              Error));            }#endif        }    }    return;} /* ScanTask() *//*****************************************************************************Name: ProcessNextScan()Description:    This routine encapsulates the tuning strategy.Parameters:    Tuner_p,    pointer to the TUNER device.    Event_p,    pointer to location to store returned event.  May be:                STTUNER_EV_NO_OPERATION,    we failed to achieve tuner lock.                STTUNER_EV_LOCKED,          the tuner is locked on a frequency.Return Value:    TUNER_NO_ERROR,     the operation completed without error.    I2C_xxxx,           there was a problem accessing a device.See Also:    Nothing.*****************************************************************************/static TUNER_ErrorCode_t ProcessNextScan(TUNER_ControlBlock_t *Tuner_p,                                         STTUNER_EventType_t *Event_p){    TUNER_ErrorCode_t Error = TUNER_NO_ERROR;    /* Check to see if we are at the end of the scan list */    if (Tuner_p->ScanInfo.ScanIndex >= Tuner_p->ScanList.NumElements)    {        U32 FrequencyEnd, FrequencyStart;        /* Calculate correct start and end frequencies */        if (Tuner_p->ScanInfo.ScanDirection < 0)        {            FrequencyEnd = Tuner_p->ScanInfo.FrequencyStart;            FrequencyStart = Tuner_p->ScanInfo.FrequencyEnd;        }        else        {            FrequencyEnd = Tuner_p->ScanInfo.FrequencyEnd;            FrequencyStart = Tuner_p->ScanInfo.FrequencyStart;        }        /* Apply next frequency step */        Tuner_p->ScanInfo.NextFrequency +=            (Tuner_p->ScanInfo.ScanDirection *               (S32)Tuner_p->ScanInfo.FrequencyStep);        /* Set frequency step to default - in case we just had a large step */        Tuner_p->ScanInfo.FrequencyStep = (Tuner_p->SymbolWidthMin / 2);        /* If we've reached the limit of our frequency range, then we should try         * and use the next polarization setting -- if there is one.         */        if (Tuner_p->ScanInfo.NextFrequency > FrequencyEnd ||            Tuner_p->ScanInfo.NextFrequency < FrequencyStart)        {            /* Shift the polarization mask along to the next valid             * polarization.             */            do            {                Tuner_p->ScanInfo.PlrMask <<= 1;            }            while (Tuner_p->ScanInfo.PlrMask != 0 &&               (Tuner_p->ScanInfo.PlrMask & Tuner_p->PolarizationMask) == 0);            /* Check there are still polarizations to check */            if (Tuner_p->ScanInfo.PlrMask != 0)            {                Tuner_p->ScanInfo.NextFrequency =                    Tuner_p->ScanInfo.FrequencyStart;            }            else            {                /* No more combinations to try -- scan has failed */                *Event_p = STTUNER_EV_SCAN_FAILED;                return Error;            }        }        /* Set scan list to beginning */        Tuner_p->ScanInfo.Scan_p = Tuner_p->ScanList.ScanList;        Tuner_p->ScanInfo.ScanIndex = 0;    }    /* Process the next frequency scan step */    Error = ProcessScanExact(Tuner_p, Event_p);    return Error;} /* ProcessNextScan() *//*****************************************************************************Name: ProcessScanExact()Description:    This routine scans for a single frequency based on the current    tuner scan parameters.Parameters:    Tuner_p,    pointer to the TUNER device.    Event_p,    pointer to location to store returned event.  May be:        STTUNER_EV_NO_OPERATION,    we failed to achieve tuner lock.        STTUNER_EV_LOCKED,          the tuner is locked on a frequency.Return Value:    TUNER_NO_ERROR,     the operation completed without error.    I2C_xxxx,           there was a problem accessing a device.See Also:    Nothing.*****************************************************************************/static TUNER_ErrorCode_t ProcessScanExact(TUNER_ControlBlock_t *Tuner_p,                                          STTUNER_EventType_t *Event_p){    TUNER_ErrorCode_t Error = TUNER_NO_ERROR;    /* Assume no lock is found */    *Event_p = STTUNER_EV_NO_OPERATION;    /* Setup the current element -- this represents a working copy we can     * modify of the current element in the scan list -- on completion it     * will be made visible to the ST TUNER API.     */    Tuner_p->CurrentTunerInfo.ScanInfo = *Tuner_p->ScanInfo.Scan_p;#if 0    /* Check that the symbol rate is supported */    if (Tuner_p->CurrentTunerInfo.ScanInfo.SymbolRate >=        Tuner_p->Capability.SymbolMin &&        Tuner_p->CurrentTunerInfo.ScanInfo.SymbolRate <=        Tuner_p->Capability.SymbolMax)#endif    {        /* Mask with the capabilties of the device */        Tuner_p->CurrentTunerInfo.ScanInfo.Modulation &=            Tuner_p->Capability.Modulation;        /* Mask with current polarization mask */        Tuner_p->CurrentTunerInfo.ScanInfo.Polarization &=            Tuner_p->ScanInfo.PlrMask;        /* Check the LNB polarization is the current */        if (Tuner_p->CurrentTunerInfo.ScanInfo.Polarization != 0)        {            /* Proceed only if it is a valid band */            if (Tuner_p->CurrentTunerInfo.ScanInfo.Band <                Tuner_p->BandList.NumElements)            {                SAT_Config_t SatConfig;                U32 ScanFrequency;                U32 NewFrequency;                BOOL ScanSuccess = FALSE;                STTUNER_Band_t *Band_p;                DEMOD_FECRate_t Fec;                /* Set requested band */                Band_p = &Tuner_p->BandList.BandList[                         Tuner_p->CurrentTunerInfo.ScanInfo.Band                         ];                /* Ensure current frequency falls inside selected band */                if (Tuner_p->ScanInfo.NextFrequency >= Band_p->BandStart &&                    Tuner_p->ScanInfo.NextFrequency <= Band_p->BandEnd)                {                    /* Set the Satellite Dish LNB power to ON */                    SatConfig.LNBStatus = SAT_LNB_ON;                    /* Setup the Satellite Dish LNB Polarization */                    SatConfig.Polarization =                                            Tuner_p->CurrentTunerInfo.ScanInfo.Polarization;                    /* Setup the require tone state */