srvrcv.c

本程序为ST公司开发的源代码

/*! \brief    State machine for hf detection
 *  \param    t_check_hf_caller check_hf_caller
 *  \return   t_hf_event hf_event
 *  \remark
 */
/******************************************************************************/

t_hf_event check_hf_fsm(t_check_hf_caller check_hf_caller)
{
  t_hf_event hf_event = (t_hf_event)HF_NO_EVENT;

  if (CHECK_HF_CALLER_FORCE_HF_LOST_CMD == check_hf_caller)
  {
    check_hf_fsm_state = CHECK_HF_STATE_LOST;
    hf_event = HF_EVENT_LOST;
  }

#ifdef HAVE_DEBUG_SERVO_HF_STATE
  if (check_hf_fsm_state != previous_check_hf_fsm_state)
  {
    DEBUG_SERVO_HF_STATE(("HF_STATE:", 1, 1, check_hf_fsm_state));
    previous_check_hf_fsm_state = check_hf_fsm_state;
  }
#endif   /* HAVE_DEBUG_SERVO_TRACKING_STATE */

  switch (check_hf_fsm_state)
  {
  case CHECK_HF_STATE_LOST:
    if (CHECK_HF_CALLER_DSP_ACQ_DEFECT_ABSENT == check_hf_caller)
    {
      start_timer(SERVO_CHECK_HF_TIMER, servo_startup_flags.field.hf_found ? DEF_OPU_PRO_HF_FOUND_DETECTION_TIME : DEF_OPU_PRO_HF_FOUND_DETECTION_TIME_1ST);
      check_hf_fsm_state = CHECK_HF_STATE_WAIT_FOR_FOUND;
    }
    break;

  case CHECK_HF_STATE_WAIT_FOR_FOUND:
    if (!timer_in_progress(SERVO_CHECK_HF_TIMER))
    {
      check_hf_fsm_state = CHECK_HF_STATE_FOUND;
      hf_event = HF_EVENT_FOUND;
      DEBUG_SERVO_HF_EVENT(("HF_EVENT: HF found", 4, 0));
    }
    else if (CHECK_HF_CALLER_DSP_ACQ_DEFECT_PRESENT == check_hf_caller)
    {
      check_hf_fsm_state = CHECK_HF_STATE_LOST;
    }
    break;

  case CHECK_HF_STATE_FOUND:
    if (CHECK_HF_CALLER_DSP_ACQ_DEFECT_PRESENT == check_hf_caller)
    {
      start_timer(SERVO_CHECK_HF_TIMER, DEF_OPU_PRO_HF_LOST_DETECTION_TIME);
      check_hf_fsm_state = CHECK_HF_STATE_WAIT_FOR_LOST;
    }
    break;

  case CHECK_HF_STATE_WAIT_FOR_LOST:
    if (!timer_in_progress(SERVO_CHECK_HF_TIMER))
    {
      check_hf_fsm_state = CHECK_HF_STATE_LOST;
      hf_event = HF_EVENT_LOST;
      DEBUG_SERVO_HF_EVENT(("HF_EVENT: HF lost", 4, 0));
    }
    else if (CHECK_HF_CALLER_DSP_ACQ_DEFECT_ABSENT == check_hf_caller)
    {
      check_hf_fsm_state = CHECK_HF_STATE_FOUND;
    }
    break;
  }

  return hf_event;
}


/******************************************************************************/
/* Function:  check_hf_fsm_call                                               */
/*                                                                            */
/*! \brief    State machine for hf detection
 *  \param    t_check_hf_caller check_hf_caller
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void check_hf_fsm_call(t_check_hf_caller check_hf_caller)
{
  t_hf_event hf_event;

  event_disable_scheduling();
  hf_event = check_hf_fsm(check_hf_caller);
  if (check_hf_caller < CHECK_HF_CALLER_MAX_CMD)
  {
    if (HF_NO_EVENT != hf_event)
    {
      event_pending[HF_EVENT].event = HF_NO_EVENT;
      event_in[HF_EVENT].event = hf_event;
    }
  }
  else
  {
    set_hf_event(hf_event);
    event_out_shedule(HF_EVENT);
  }
  event_enable_scheduling();
}


#ifdef APM_PICKUP

/******************************************************************************/
/* Function:  ttm_recover                                                   */
/*                                                                            */
/*! \brief    ttm recover strategy
 *  \param    void
 *  \return   uint8; IN_PROGRESS if still busy
 *            OK if finished
 *  \remark   assumption: TTM feedback is available
 */
/******************************************************************************/

RETVAL ttm_recover(void)
{
  RETVAL ttm_recover_result;

#ifdef KEEP_FOCUS_DURING_TTM_RECOVER
  ttm_recover_result = check_servo(CHECK_FOCUS);
  if ((ttm_recover_result == OK) || (servo_recover_flags.field.focus_missing))
#endif   /* KEEP_FOCUS_DURING_TTM_RECOVER */
  {
    ttm_recover_result = IN_PROGRESS;

    switch (ttm_recover_state)
    {
    case STATE_1:
      stop_activity();
      servo_recover_flags.field.ttm_recover_active = 1;
      ttm_recover_state = STATE_2;
      /* fall through */

    case STATE_2:
      if (short_jump_braking() == OK)
      {
        track_off();
        stop_sledge(SLEDGE_PRO_ACCELERATION_NORMAL);
#ifdef KEEP_FOCUS_DURING_TTM_RECOVER
        if (servo_recover_flags.field.focus_missing)
        {
          ttm_recover_state = STATE_3;
        }
        else
        {
          ttm_recover_state = STATE_4;
        }
#else   /* (do not) KEEP_FOCUS_DURING_TTM_RECOVER */
        ttm_recover_state = STATE_3;
#endif   /* KEEP_FOCUS_DURING_TTM_RECOVER */
      }
      break;

    case STATE_3:
      if (focus_off() == OK)
      {
        focus_recover_state = STATE_4;
      }
      break;

    //case STATE_4:
    default:
      if (sledge_stopped())
      {
        ttm_recover_result = OK;
      }
      break;
    }
  }
  /* else not needed   ((ttm_recover_result = check_servo(CHECK_FOCUS)) == FOCUS_LOST) */

  return ttm_recover_result;
}

#else   /* (not) APM_PICKUP */

/******************************************************************************/
/* Function:  ttm_recover                                                   */
/*                                                                            */
/*! \brief    ttm recover strategy
 *  \param    void
 *  \return   void
 *  \remark   assumption: TTM feedback is not available
 */
/******************************************************************************/

void ttm_recover(void)
{
  servo_recover_flags.field.ttm_recover_active = 1;
}

#endif /* APM_PICKUP */


/******************************************************************************/
/* Function:  focus_recover                                                   */
/*                                                                            */
/*! \brief    selects the focus recover strategy
 *  \param    void
 *  \return   uint8; IN_PROGRESS if still busy
 *            OK if finished
 *  \remark   Unlock PLL, opens tracking loop and stops sledge. According to
 *            Sledge position and past status (home_position, during jump..)
 *            focus_recover_direction is chosen and a sledge move is executed
 */
/******************************************************************************/

RETVAL focus_recover(void)
{
  RETVAL focus_recover_result;
  sint16 focus_recover_sledge_param;

#ifdef APM_PICKUP
  focus_recover_result = check_servo(CHECK_TTM);
#ifdef KEEP_FOCUS_DURING_TTM_RECOVER
  if ((focus_recover_result == OK) || (servo_recover_flags.field.ttm_recover_active))
#else   /* (do not) KEEP_FOCUS_DURING_TTM_RECOVER */
  if (focus_recover_result == OK)
#endif   /* KEEP_FOCUS_DURING_TTM_RECOVER */
#endif   /* APM_PICKUP */
  {
    focus_recover_result = IN_PROGRESS;

    switch (focus_recover_state)
    {
    case STATE_1:
      stop_activity();
      servo_recover_flags.field.focus_missing = 1;
      focus_recover_state = STATE_2;
      /* fall through */

    case STATE_2:
      /* HW060116a - BEGIN */
      if (short_jump_braking() == OK)
      {
        track_off();
        stop_sledge(SLEDGE_PRO_ACCELERATION_NORMAL);
        focus_recover_state = STATE_3;
      }
      /* HW060116a - END */
      break;

    case STATE_3:
      if (focus_off() == OK)
      {
        focus_recover_state = STATE_4;
      }
      break;

    case STATE_4:
      if (sledge_stopped())
      {
#if defined(APM_PICKUP) && defined(KEEP_FOCUS_DURING_TTM_RECOVER)
        if (servo_recover_flags.field.ttm_recover_active)
        {
          focus_recover_result = START_TTM_REQUEST;
        }
        else
#endif   /* APM_PICKUP && KEEP_FOCUS_DURING_TTM_RECOVER */
        {
          focus_recover_sledge_param = RECOVER_PRO_FOCUS_RECOVER_SLEDGE_PARAM;
          if ((home_position()) || (switch_reached_moving_inside()))
          {
            sledge_param = focus_recover_sledge_param;
            servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_OUTSIDE;
            focus_recover_outside_retries = RECOVER_PRO_FOCUS_RECOVER_OUTSIDE_RETRIES;
          }
          else
          {
            if ((servo_recover_flags.field.focus_recover_mode == FOCUS_PRESENT_IN_CURRENT_POSITION)
             && (timer_in_progress(SERVO_FOCUS_FOUND_TIMER)))
            {
              servo_recover_flags.field.focus_recover_mode = FOCUS_NOT_PRESENT_IN_CURRENT_POSITION;
            }

            switch (servo_recover_flags.field.focus_recover_mode)
            {
            case FOCUS_PRESENT_IN_CURRENT_POSITION:
              sledge_param = 0;
              servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;
              break;

            case FOCUS_NOT_PRESENT_IN_CURRENT_POSITION:
              if (servo_recover_flags.field.next_focus_recover_direction == FOCUS_RECOVER_INSIDE)
              {
                sledge_param = -focus_recover_sledge_param;
              }
              else   /* (servo_recover_flags.field.next_focus_recover_direction == FOCUS_RECOVER_OUTSIDE) */
              {
                focus_recover_outside_retries--;
                if (focus_recover_outside_retries != 0)
                {
                  sledge_param = focus_recover_sledge_param;
                }
                else
                {
                  if (!servo_startup_flags.field.fe_adjust_done)
                  {
                    focus_recover_result = MEDIA_NOT_FOUND;
                  }
                  else
                  {
                    sledge_param = -focus_recover_sledge_param;
                    servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;
                  }
                }
              }
              break;

            case FOCUS_LOST_DURING_JUMP:
              sledge_param = -sign(delta_trk) * focus_recover_sledge_param;
              servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;
              break;

            case FOCUS_LOST_DURING_HF_RECOVER:
              sledge_param = -sign(sledge_param) * focus_recover_sledge_param;
              servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;
              break;

            //case FOCUS_LOST_DURING_ERASED_CD_RW_RECOVER:
            //case FOCUS_LOST_DURING_PLL_RECOVER:
            default:
              sledge_param = focus_recover_sledge_param;
              servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;
              break;
            }

            servo_recover_flags.field.focus_recover_mode = FOCUS_NOT_PRESENT_IN_CURRENT_POSITION;
          }
          focus_recover_state = STATE_5;
        }
      }
      break;

    //case STATE_5:
    default:
      focus_recover_result = sledge_move();
      if ((focus_recover_result == OK) && (!servo_startup_flags.field.fe_adjust_done))
      {
        focus_recover_result = FE_ADJUST_REQUEST;
      }
      break;
    }
  }
  /* else not needed   ((focus_recover_result = check_servo(CHECK_TTM)) == TTM_STOPPED) */

  return focus_recover_result;