srvjmp.c

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

      {
        reset_short_jump(RESET_SHORT_JUMP_BRAKING);
        short_jump_execution_result = OK;
      }
      break;
    }
  }
  /* else not needed   ((short_jump_execution_result = check_servo(CHECK_TTM | CHECK_FOCUS | CHECK_HF)) == TTM_STOPPED / FOCUS_LOST / HF_LOST) */

  return short_jump_execution_result;
}


/******************************************************************************/
/* Function:  short_jump_braking                                                   */
/*                                                                            */
/*! \brief    stops short jump and waits for short jump finished (master jump)
 *  \param    void
 *  \return   uint8; IN_PROGRESS if still busy
 *            OK if finished
 *  \remark   Bit stop master jump is set and then wait for bit short jump completed
 *            is set  in control register.
 *            HW060116a
 *
 */
/******************************************************************************/

RETVAL short_jump_braking(void)
{
  RETVAL short_jump_braking_result;

  short_jump_braking_result = IN_PROGRESS;

  switch (short_jump_braking_state)
  {
  case STATE_1:
    stop_short_jump();
    short_jump_braking_state = STATE_2;
    /* fall through */

  case STATE_2:
    if (short_jump_stopped())
    {
      reset_short_jump(RESET_SHORT_JUMP_BRAKING);
      short_jump_braking_result = OK;
    }
    break;
  }

  return short_jump_braking_result;
}


/******************************************************************************/
/* Function:  short_jump                                                      */
/*                                                                            */
/*! \brief    Routine executing short jump (Actuator jump with sledge as slave)
 *  \param    void
 *  \return   RETVAL short_jump_result, OK / IN_PROGRESS / FOCUS_LOST / HF_LOST
 *  \remark   short_jump() is called in JUMP_CHECK_STATE. The jump is executed
 *            and presence of HF and FOCUS is observed. RATE is programmed to
 *            execute jump. Sledge is adjusted by DSP. Tracking loop is held
 *            closed.
 */
/******************************************************************************/

RETVAL short_jump(void)
{
  RETVAL short_jump_result;

  if ((short_jump_state != STATE_1) && (!timer_in_progress(SERVO_SAFETY_TIMER)))
  {
    short_jump_result = SHORT_JUMP_TIMEOUT_ERROR;
  }
  else
  {
    short_jump_result = IN_PROGRESS;

    switch (short_jump_state)
    {
    case STATE_1:
      DEBUG_SERVO(("short_jump()", 2, 1, delta_trk));
      set_disc_control(DISC_CONTROL_SHORT_JUMP);
      dsp_write_xmem(BW_SWITCH_ADD, 0x6000);
      track_off();
      start_timer(SERVO_SAFETY_TIMER, SEEK_PRO_SHORT_JUMP_TIMEOUT);
      short_jump_state = STATE_2;
      break;

    case STATE_2:
      switch (short_jump_execution())
      {
      case IN_PROGRESS:
        break;

      case OK:
        short_jump_state = STATE_3;
        break;

      case FOCUS_LOST:
        servo_recover_flags.field.focus_recover_mode = FOCUS_LOST_DURING_JUMP;
        short_jump_result = FOCUS_LOST;
        break;

      //case HF_LOST:
      default:
        servo_recover_flags.field.hf_recover_mode = HF_LOST_DURING_JUMP;
        short_jump_result = HF_LOST;
        break;
      }
      break;

    //case STATE_3:
    default:
      short_jump_result = track_on();
      DEBUG_SERVO(("short_jump OK", 4, 0));
      break;
    }
  }

  return short_jump_result;
}


/******************************************************************************/
/* Function:  long_jump                                                       */
/*                                                                            */
/*! \brief    Routine executing long jump (sledge jump with track off )
 *  \param    void
 *  \return   RETVAL long_jump_result, OK / IN_PROGRESS / FOCUS_LOST / HF_LOST
 *  \remark   long_jump() is called in JUMP_CHECK_STATE. The jump is executed
 *            and presence of HF and FOCUS is observed.
 *            Tracking controller is switched off and sledge is moved for xx steps
 *            following a defined acceleration/constant speed/brake curve.
 */
/******************************************************************************/

RETVAL long_jump(void)
{
  RETVAL long_jump_result;

  if ((long_jump_state != STATE_1) && (!timer_in_progress(SERVO_SAFETY_TIMER)))
  {
    long_jump_result = LONG_JUMP_TIMEOUT_ERROR;
  }
  else
  {
    long_jump_result = IN_PROGRESS;

    switch (long_jump_state)
    {
    case STATE_1:
      DEBUG_SERVO(("long_jump()", 2, 1, delta_trk));
      set_disc_control(DISC_CONTROL_LONG_JUMP);
      dsp_write_xmem(BW_SWITCH_ADD, 0x6000);
      track_off();
#ifdef APM_PICKUP
      sledge_distance = aux_mult(delta_trk, TRK_2_STEP);
#else
      sledge_param = sign(delta_trk) * SLEDGE_PRO_SEEK_PARAM;
#endif
      start_timer(SERVO_SAFETY_TIMER, SEEK_PRO_LONG_JUMP_TIMEOUT);
      long_jump_state = STATE_2;
      break;

    case STATE_2:
      switch (sledge_move_long_jump())
      {
      case IN_PROGRESS:
        break;

      case OK:
        long_jump_state = STATE_3;
        break;

      case FOCUS_LOST:
        long_jump_result = FOCUS_LOST;
        servo_recover_flags.field.focus_recover_mode = FOCUS_LOST_DURING_JUMP;
        break;

      //case HF_LOST:
      default:
        long_jump_result = HF_LOST;
        servo_recover_flags.field.hf_recover_mode = HF_LOST_DURING_JUMP;
        break;
      }
      break;

    //case STATE_3:
    default:
      long_jump_result = track_on();
      DEBUG_SERVO(("long_jump OK", 4, 0));
      break;
    }
  }
  return long_jump_result;
}


/******************************************************************************/
/* Function:  jump_check                                                      */
/*                                                                            */
/*! \brief    function called into jump_check_state()
 *  \param    void
 *  \return   RETVAL jump_check_result, OK / IN_PROGRESS / FOCUS_LOST / HF_LOST
 *  \remark   Called in state machine. Executes desired jump.
 */
/******************************************************************************/

RETVAL jump_check(void)
{
  if (servo_seek_flags.field.jump_type == LONG_JUMP)
  {
    return long_jump();
  }
  else   /* (servo_seek_flags.field.jump_type == SHORT_JUMP) */
  {
    return short_jump();
  }
}


#ifdef APM_PICKUP
/******************************************************************************/
/* Function:  service_jump                                                    */
/*                                                                            */
/*! \brief    executes a jump, called from service function/dbg interface
 *  \param    int16 trkno
 *  \return   RETVAL result, OK / IN_PROGRESS / FOCUS_LOST / HF_LOST
 *  \remark   Only to be called from dbgprc.c
 */
/******************************************************************************/

RETVAL service_jump(int16 trkno)
{
  delta_trk = trkno;
  if (absi(delta_trk) > SEEK_PRO_LONG_SHORT_JUMP_THS)
  {
    return long_jump();
  }
  else
  {
    return short_jump();
  }
}
#endif

#endif // HAVE_CD_MECHA