srvrcv.c

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

}


/******************************************************************************/
/* Function:  tracking_recover                                                */
/*                                                                            */
/*! \brief    Unlocks PLL, open tracking loop
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void tracking_recover(void)
{
  stop_activity();
  track_off();
}


/******************************************************************************/
/* Function:  hf_recover                                                      */
/*                                                                            */
/*! \brief    selects the hf recover strategy
 *  \param    void
 *  \return   SLEDGE_RECOVER_REQUEST in case of sledge recover needed
 *            MAX_SERVO_RETRIES_ERROR in case of servo retries limit reached
 *  \remark
 */
/******************************************************************************/

RETVAL hf_recover(void)
{
  RETVAL hf_recover_result;
  sint16 hf_recover_sledge_param;

  hf_recover_result = check_servo(CHECK_TTM | CHECK_FOCUS);
  if ((hf_recover_result == OK)
   || ((hf_recover_result == FOCUS_LOST)
    && (hf_recover_state == STATE_4)
    && (sledge_move_hf_state > STATE_2)))
  {
    hf_recover_result = IN_PROGRESS;

    switch (hf_recover_state)
    {
    case STATE_1:
      stop_activity();
      hf_recover_state = STATE_2;
      /* fall through */

    case STATE_2:
/* HW060116a - BEGIN */
      if (short_jump_braking() == OK)
      {
        track_off();
        dsp_write_xmem(BW_SWITCH_ADD, 0x6000);
        stop_sledge(SLEDGE_PRO_ACCELERATION_NORMAL);
        hf_recover_state = STATE_3;
      }
/* HW060116a - END */
      break;

    case STATE_3:
      if (sledge_stopped())
      {
#ifdef APM_PICKUP
        hf_recover_sledge_param = RECOVER_PRO_HF_RECOVER_SLEDGE_PARAM;
#else
        if (!servo_startup_flags.field.hf_found)
        {
          hf_recover_sledge_param = RECOVER_PRO_HF_RECOVER_INITIAL_SLEDGE_PARAM;
        }
        else if ((HF_LOST_DURING_JUMP == servo_recover_flags.field.hf_recover_mode)
              || (HF_LOST_DURING_PLL_RECOVER == servo_recover_flags.field.hf_recover_mode))
        {
          hf_recover_sledge_param = RECOVER_PRO_HF_RECOVER_JUMP_SLEDGE_PARAM;
        }
        else
        {
          hf_recover_sledge_param = RECOVER_PRO_HF_RECOVER_PLAY_SLEDGE_PARAM;
        }
#endif

        if ((home_position()) || (switch_reached_moving_inside()))
        {
          sledge_param = hf_recover_sledge_param;
          servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_OUTSIDE;
        }
        else
        {
          switch (servo_recover_flags.field.hf_recover_mode)
          {
          case HF_PRESENT_IN_CURRENT_POSITION:
            sledge_param = -hf_recover_sledge_param;
            servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;
            break;

          case HF_NOT_PRESENT_IN_CURRENT_POSITION:
            if (servo_recover_flags.field.next_hf_recover_direction == HF_RECOVER_INSIDE)
            {
              sledge_param = -hf_recover_sledge_param;
            }
            else   /* (servo_recover_flags.field.next_hf_recover_direction == HF_RECOVER_OUTSIDE) */
            {
              sledge_param = hf_recover_sledge_param;
            }
            break;

          case HF_LOST_DURING_JUMP:
            sledge_param = -sign(delta_trk) * hf_recover_sledge_param;
            servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;
            break;

          //case HF_LOST_DURING_PLL_RECOVER:
          default:
            sledge_param = -hf_recover_sledge_param;
            servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;
            break;
          }

          servo_recover_flags.field.hf_recover_mode = HF_NOT_PRESENT_IN_CURRENT_POSITION;
        }
        hf_recover_state = STATE_4;
      }
      break;

    //case STATE_4:
    default:
      switch (hf_recover_result = sledge_move_hf())
      {
      case IN_PROGRESS:
        break;

      case OK:
        servo_recover_flags.field.hf_recover_mode = HF_PRESENT_IN_CURRENT_POSITION;
        if (!servo_startup_flags.field.hf_found)
        {
          servo_startup_flags.field.hf_found = 1;
          servo_startup_flags.field.fe_adjust_done = 0;
          hf_recover_result = FE_ADJUST_REQUEST;
        }
        break;

      case HF_NOT_FOUND:
        if (!servo_startup_flags.field.hf_found)
        {
          hf_recover_result = HF_SEARCH_AFTER_HF_NOT_FOUND;
        }
#ifndef APM_PICKUP
        else
        {
          hf_recover_result = TTM_STOPPED;
        }
#endif

        if (sledge_param > 0)
        {
          if (!servo_startup_flags.field.hf_found)
          {
            hf_recover_result = UNWRITTEN_DISC_HF_REC;   /* BB050815g */
          }
          else
          {
            servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;
          }
        }
        break;

      //case FOCUS_LOST:
      default:
        if (!servo_startup_flags.field.hf_found)
        {
          hf_recover_result = HF_SEARCH_AFTER_FOCUS_LOST;
        }
        servo_recover_flags.field.focus_recover_mode = FOCUS_LOST_DURING_HF_RECOVER;
        servo_recover_flags.field.focus_lost_during_hf_recover_retries--;
        if (servo_recover_flags.field.focus_lost_during_hf_recover_retries == 0)
        {
          if (sledge_param > 0)
          {
            if (!servo_startup_flags.field.hf_found)
            {
              hf_recover_result = UNWRITTEN_DISC_HF_REC;   /* BB050815g */
            }
            else
            {
              servo_recover_flags.field.focus_lost_during_hf_recover_retries = RECOVER_PRO_FOCUS_LOST_DURING_HF_RECOVER_RETRIES;
              servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;
            }
          }
          else
          {
            servo_recover_flags.field.focus_lost_during_hf_recover_retries = RECOVER_PRO_FOCUS_LOST_DURING_HF_RECOVER_RETRIES;
            servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_OUTSIDE;
          }
        }
        break;
      }
      break;
    }
  }
  /* else not needed   ((hf_recover_result = check_servo(CHECK_TTM)) == TTM_STOPPED) */

  return hf_recover_result;
}


/******************************************************************************/
/* Function:  erased_cd_rw_recover                                            */
/*                                                                            */
/*! \brief    Unlocks PLL, open tracking loop, chooses recovery direction
 *  \param    void
 *  \return   uint8, IN_PROGRESS, OK or UNWRITTEN_DISC
 *  \remark
 */
/******************************************************************************/

RETVAL erased_cd_rw_recover(void)
{
  RETVAL erased_cd_rw_recover_result;

  erased_cd_rw_recover_result = check_servo(CHECK_TTM);
  if (erased_cd_rw_recover_result == OK)
  {
    erased_cd_rw_recover_result = IN_PROGRESS;

    switch (erased_cd_rw_recover_state)
    {
    case STATE_1:
      stop_activity();
      track_off();
      dsp_write_xmem(BW_SWITCH_ADD, 0x6000);

      if ((home_position()) || (switch_reached_moving_inside()))
      {
        erased_cd_rw_recover_result = UNWRITTEN_DISC_CDRW_REC;   /* BB050815g */
      }
      else
      {
        sledge_param = -RECOVER_PRO_ERASED_CD_RW_RECOVER_SLEDGE_PARAM;
        erased_cd_rw_recover_state = STATE_2;
      }
      break;

    //case STATE_2:
    default:
      switch (erased_cd_rw_recover_result = sledge_move_relock())
      {
      case IN_PROGRESS:
      case OK:
        break;

      case HF_LOST:
        if (!servo_startup_flags.field.mode1_found)
        {
          erased_cd_rw_recover_result = UNWRITTEN_DISC_CDRW_REC;   /* BB050815g */
        }
        else
        {
          servo_recover_flags.field.hf_recover_mode = HF_LOST_DURING_ERASED_CD_RW_RECOVER;
        }
        break;

      //case FOCUS_LOST:
      default:
        if (!servo_startup_flags.field.mode1_found)
        {
          erased_cd_rw_recover_result = MODE1_SEARCH_AFTER_FOCUS_LOST;
        }
        servo_recover_flags.field.focus_recover_mode = FOCUS_LOST_DURING_ERASED_CD_RW_RECOVER;
        servo_recover_flags.field.focus_lost_during_erased_cd_rw_recover_retries--;
        if ((servo_recover_flags.field.focus_lost_during_erased_cd_rw_recover_retries == 0)
         && (!servo_startup_flags.field.mode1_found))
        {
          erased_cd_rw_recover_result = UNWRITTEN_DISC_CDRW_REC;   /* BB050815g */
        }
        break;
      }
      break;
    }
  }
  /* else not needed   ((erased_cd_rw_recover_result = check_servo(CHECK_TTM)) == TTM_STOPPED) */

  return erased_cd_rw_recover_result;
}


/******************************************************************************/
/* Function:  pll_recover                                                     */
/*                                                                            */
/*! \brief    Unlocks PLL, open tracking loop, chooses recovery direction
 *  \param    void
 *  \return   uint8, IN_PROGRESS, OK
 *  \remark
 */
/******************************************************************************/

RETVAL pll_recover(void)
{
  RETVAL pll_recover_result;

  pll_recover_result = check_servo(CHECK_TTM);
  if (pll_recover_result == OK)
  {
    pll_recover_result = IN_PROGRESS;

    switch (pll_recover_state)
    {
    case STATE_1:
      stop_activity();
      track_off();
      dsp_write_xmem(BW_SWITCH_ADD, 0x6000);

#ifdef APM_PICKUP
      sledge_param = RECOVER_PRO_PLL_RECOVER_SLEDGE_PARAM;
#else
      sledge_param = -RECOVER_PRO_PLL_RECOVER_SLEDGE_PARAM;
#endif

      pll_recover_state = STATE_2;
      break;

    //case STATE_2:
    default:
      switch (pll_recover_result = sledge_move_relock())
      {
      case IN_PROGRESS:
      case OK:
        break;

      case HF_LOST:
        servo_recover_flags.field.hf_recover_mode = HF_LOST_DURING_PLL_RECOVER;
        break;

      //case FOCUS_LOST:
      default:
        servo_recover_flags.field.focus_recover_mode = FOCUS_LOST_DURING_PLL_RECOVER;
        break;
      }
      break;
    }
  }
  /* else not needed   ((pll_recover_result = check_servo(CHECK_TTM)) == TTM_STOPPED) */

  return pll_recover_result;
}


#endif // HAVE_CD_MECHA