srvctr.c

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

    if (IS_LOADER_STOP_POSITION())
    {
      if (0 == (CDinfo & (DISC_8CM | DISC_12CM)))
      {
        /* Only if CDinfo is cleared */
        if (IS_LOADER_8CM_STOP_POSITION())
        {
          CDinfo |= DISC_8CM;
        }
        else   // (IS_LOADER_12CM_STOP_POSITION)
        {
          CDinfo |= DISC_12CM;
        }
      }
      init_servo_for_new_disc_state = STATE_2;
    }
    else if (!IS_TANASHIN_MECHANISM(mechanism_model))
    {
      init_servo_for_new_disc_state = STATE_2;
    }
    else
    {
      init_servo_for_new_disc_result = OK;
    }
#endif
    break;

#ifdef APM_PICKUP
  case STATE_2:
    switch (sledge_home())
    {
    case IN_PROGRESS:
      break;

    case OK:
      init_servo_for_new_disc_state = STATE_3;
      break;

    //case SLEDGE_ERROR:
    default:
      init_servo_for_new_disc_result = SLEDGE_ERROR;
      break;
    }
    break;

  //case STATE_3:
  default:
    switch (check_ttm_braking())
    {
    case IN_PROGRESS:
      break;

    //case STOP_TTM_ERROR:
    //case OK:
    default:
      DRIVER_OFF;
      servo_misc_flags.field.init_for_new_disc_done = 1;
      if (servo_misc_flags.field.start_request)
      {
        servo_misc_flags.field.start_request = 0;
        init_servo_for_new_disc_result = START_REQUEST;
      }
      else
      {
        init_servo_for_new_disc_result = OK;
      }
      break;
    }
    break;

#else   /* (not) APM_PICKUP */

  //case STATE_2:
  default:
    switch (sledge_home())
    {
    case IN_PROGRESS:
      break;

    case OK:
      DRIVER_OFF;
      servo_misc_flags.field.init_for_new_disc_done = 1;
      if (servo_misc_flags.field.start_request)
      {
        servo_misc_flags.field.start_request = 0;
        init_servo_for_new_disc_result = START_REQUEST;
      }
      else
      {
        init_servo_for_new_disc_result = OK;
      }
      break;
 
    //case SLEDGE_ERROR:
    default:
      init_servo_for_new_disc_result = SLEDGE_ERROR;
      break;
    }
    break;

#endif   /* APM_PICKUP */

  }
  return init_servo_for_new_disc_result;
}


/******************************************************************************/
/* Function:  init_start                                                      */
/*                                                                            */
/*! \brief    Core function of SERVO_START state
 *  \param    void
 *  \return   RETVAL - BUSY, READY or ERROR
 *  \remark   Initialize variables + TOC info, turn on driver, move sledge home,
 *            turn on front-end
 */
/******************************************************************************/

RETVAL init_start(void)
{
  RETVAL init_start_result;

  init_start_result = IN_PROGRESS;

  switch (init_start_state)
  {
  case STATE_1:
#ifndef APM_PICKUP
    if (!servo_startup_flags.field.first_startup_sequence_completed)
    {
      reset_hostif_servo_parameters(HSP_RESET_MODE_STARTUP);
    }
#ifndef EXECUTE_AGC_ONLY_ONCE
    else
    {
      reset_hostif_servo_parameters(HSP_RESET_MODE_RESTART);
    }
#endif
#endif

    servo_startup_flags.field.ttm_started = 0;
#ifndef EXECUTE_AGC_ONLY_ONCE
    servo_startup_flags.field.agc_focus_done = 0;
    servo_startup_flags.field.agc_tracking_done = 0;
#endif

    lastrecovery_T = 0; /* PH050126a */

    servo_recover_flags.all = SERVO_RECOVER_FLAGS_INIT;
    /* servo_recover_flags.field.focus_recover_mode = FOCUS_NOT_PRESENT_IN_CURRENT_POSITION; */
    /* servo_recover_flags.field.hf_recover_mode = HF_NOT_PRESENT_IN_CURRENT_POSITION;       */
    /* servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_INSIDE;        */
    /* servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_INSIDE;              */
    /* servo_recover_flags.field.focus_lost_during_hf_recover_counter = 0;                   */
    /* servo_recover_flags.field.focus_lost_during_erased_cd_rw_recover_counter = 0;         */
    /* servo_recover_flags.field.focus_missing = 1;      */
    /* servo_recover_flags.field.ttm_recover_active = 0; */

    tracking_recover_dither_counter = 0;

#ifdef FOCUS_RECOVERY_ONLY_OUTSIDE_DURING_FIRST_FE_ADJUST
    if (!servo_startup_flags.field.fe_adjust_done)
    {
      focus_recover_outside_retries = RECOVER_PRO_FOCUS_RECOVER_OUTSIDE_RETRIES;
      servo_recover_flags.field.next_focus_recover_direction = FOCUS_RECOVER_OUTSIDE;
    }
#endif

#ifdef HF_RECOVERY_ONLY_OUTSIDE_DURING_FIRST_HF_SEARCH
    if (!servo_startup_flags.field.hf_found)
    {
      servo_recover_flags.field.next_hf_recover_direction = HF_RECOVER_OUTSIDE;
    }
#endif

#ifdef APM_PICKUP
    ACT_AND_TT_ON_SCBM;
#else
    DRIVER_ON;
#endif

    if (servo_misc_flags.field.sledge_home_request)
    {
      servo_misc_flags.field.sledge_home_request = 0;
      init_start_state = STATE_2;
    }
    else
    {
      init_start_state = STATE_3;
    }
    break;

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

    case OK:
      init_start_state = STATE_3;
      break;

    //case SLEDGE_ERROR:
    default:
      init_start_result = SLEDGE_ERROR;
      break;
    }
    break;

  //case STATE_3:
  default:
    abcdef_on();
    laser_on();
    if (check_ttm_braking() == STOP_TTM_ERROR)
    {
      init_start_result = START_TTM_REQUEST;
    }
    else
    {
      init_start_result = OK;
    }
    break;
  }
  return init_start_result;
}


/******************************************************************************/
/* Function:  stop_activity                                                   */
/*                                                                            */
/*! \brief    Stopping DSP activities - Focus Ramping or AGC
 *  \param    void
 *  \return   void
 *  \remark   Local helper function called from stop_servo
 */
/******************************************************************************/

void stop_activity(void)
{
  dsp_write_xmem(BW_SWITCH_ADD, 0x4000);

  /* Break Running AGC */
  dsp_write_xmem(GAINADJ_ADD, AGC_NO_INJECTION);
  dsp_write_xmem(VIB_GAIN_ADD, 0x0000);

  /* Reset State / Function Timers */
  stop_timer(SERVO_SAFETY_TIMER);
  stop_timer(SERVO_FUNCTION_TIMER);

  sledge_condition = SLEDGE_CONDITION_NORMAL;
}


/******************************************************************************/
/* Function:  stop_servo                                                      */
/*                                                                            */
/*! \brief    Core function of SERVO_STOP state
 *  \param    void
 *  \return   RETVAL - BUSY, READY or ERROR
 *  \remark   Mute output, switch off controllers, break jump / sledge / TTM
 *            movement, switch off front-end, move sledge to home position
 */
/******************************************************************************/

RETVAL stop_servo(void)
{
  RETVAL stop_servo_result;

  stop_servo_result = IN_PROGRESS;
  switch (stop_servo_state)
  {
  case STATE_1:
    stop_activity();
    stop_servo_state = STATE_2;
    /* fall through */

  case STATE_2:
    if (short_jump_braking() == OK)
    {
      track_off();
      brake_ttm();
      stop_sledge(SLEDGE_PRO_ACCELERATION_NORMAL);

      if (!servo_startup_flags.field.first_startup_sequence_completed)
      {
        servo_startup_flags.all = SERVO_STARTUP_FLAGS_INIT;
        servo_misc_flags.field.sledge_home_request = 1;
      }

      /* stop toc execution */
      stop_toc();  /* BB050411b */     /* FDTODO: to be removed */

      lastrecovery_T = 0; /* PH050126a */

      stop_servo_state = STATE_3;
    }
    break;

  case STATE_3:
    if (focus_off() == OK)
    {
      laser_off();
      abcdef_off();
      stop_servo_state = STATE_4;
    }
    break;

  case STATE_4:
    if (sledge_stopped())
    {
      stop_servo_state = STATE_5;
    }
    break;

  //case STATE_5:
  default:
    if ((servo_misc_flags.field.init_request)
     || (servo_misc_flags.field.init_for_new_disc_request)
     || (!servo_misc_flags.field.start_request)
     || (!servo_startup_flags.field.fe_adjust_done))
    {
      switch (check_ttm_braking())
      {
      case IN_PROGRESS:
        break;

      //case STOP_TTM_ERROR:
      //case OK:
      default:
        if (servo_misc_flags.field.init_request)
        {
          servo_misc_flags.field.init_request = 0;
          stop_servo_result = INIT_REQUEST;
        }
        else if (servo_misc_flags.field.init_for_new_disc_request)
        {
          servo_misc_flags.field.init_for_new_disc_request = 0;
          stop_servo_result = INIT_FOR_NEW_DISC_REQUEST;
        }
        else if (servo_misc_flags.field.start_request)
        {
          servo_misc_flags.field.start_request = 0;
          stop_servo_result = START_REQUEST;
        }
        else
        {
          DRIVER_OFF;
          stop_servo_result = OK;
        }
        break;
      }
    }
    else
    {
      servo_misc_flags.field.start_request = 0;
      stop_servo_result = START_REQUEST;
    }
    break;
  }
  return stop_servo_result;
}


/******************************************************************************/
/* Function:  start_jump                                                      */
/*                                                                            */
/*! \brief    Core function of START_JUMP state
 *  \param    void
 *  \return   RETVAL - BUSY, READY or ERROR
 *  \remark   Calculation of jump distance, direction and if short or long jump
 *            is used
 */
/******************************************************************************/

RETVAL start_jump(void)
{
  uint8  start_jump_state;
  RETVAL start_jump_result;
  sint16 delta_T;

  start_jump_state = STATE_1;
  start_jump_result = RUNNING;

  while (start_jump_result == RUNNING)
  {
    switch (start_jump_state)
    {
    case STATE_1:
      DEBUG_SERVO(("start_jump() to sector: ", 4, 1, target_T));
      tracking_recover_dither_counter = 0;
      servo_seek_flags.field.starting_trk_unknown = 0;
      servo_seek_flags.field.from_leadin_to_target = 0;
      if (servo_seek_flags.field.seek_state == NEW_SEEK_REQUESTED)
      {
        servo_seek_flags.field.seek_state = SEEK_IN_PROGRESS;

        if (servo_seek_flags.field.seek_mode == JUMP_TRACKS)
        {
          if ((servo_acq_flags.field.new_T) && (T_actual))
          {
            servo_seek_flags.field.starting_trk_unknown = 1;
          }
          else   /* (!((servo_acq_flags.field.new_T) && (T_actual))) */
          {
            starting_trk = DISC_R;
          }
          delta_trk = skip_trk;
          start_jump_state = STATE_3;
        }
        else
        {
          corrective_jumps_counter = SEEK_PRO_MAX_CORRECTIVE_JUMPS;
          target_trk = (uint16)sector_2_trk(target_T);
          if (servo_seek_flags.field.seek_mode == JUMP_TARGET_PLUS_TRACKS)
          {
            target_trk += skip_trk;
          }
          T_ths = target_trk / (DISC_C >> 1);
          start_jump_state = STATE_2;
        }
      }