srvctr.c

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

      else   /* (servo_seek_flags.field.seek_state == SEEK_IN_PROGRESS) */
      {
        start_jump_state = STATE_2;
      }
      break;

    case STATE_2:
      if ((servo_acq_flags.field.new_T) && (T_actual))  /* If there is no T_actual, we are also in 1st LI */
      {
        starting_trk = (uint16)sector_2_trk(T_actual);
        if ((servo_seek_flags.field.seek_mode != SEEK_TARGET)
         || (target_T > (T_actual + SEEK_PRO_CLOSE_TRACKS_THS * T_ths))
         || (T_actual > (target_T + SEEK_PRO_CLOSE_TRACKS_THS * T_ths)))
        {
          delta_trk = (sint16)(target_trk - starting_trk);
        }
        else
        {
          delta_T = (sint16)((target_T - SEEK_PRO_MARGIN_SECTORS) - T_actual);
          delta_trk = delta_T / (sint16)T_ths;

          if (((delta_trk != 0) || (target_T <= T_actual)) && (delta_trk * T_ths > delta_T))
          {
            delta_trk--;
          }
        }
      }
      else   /* (!(servo_acq_flags.field.new_T && (T_actual))) */
      {
        starting_trk = DISC_R;
        delta_trk = TRACKS_OUT_LEADIN;
        servo_seek_flags.field.from_leadin_to_target = 1;
      }
      start_jump_state = STATE_3;
      break;

    //case STATE_3:
    default:
      start_jump_result = OK;
      servo_seek_flags.field.jump_type = SHORT_JUMP;

      if (delta_trk != 0)
      {
        if (((delta_trk >= 0)
          || ((!home_position()) && (!switch_reached_moving_inside())))
         && (absi(delta_trk) > SEEK_PRO_LONG_SHORT_JUMP_THS))
        {
          servo_seek_flags.field.jump_type = LONG_JUMP;
        }
      }
      else if (T_actual >= target_T)   /* && (delta_trk == 0) */
      {
        delta_trk = -1;
      }
      else   /* ((delta_trk == 0) && (T_actual < target_T)) */
      {
        start_jump_result = SKIP_TO_ACCESS_CHECK;
      }
      break;
    }
  }
  return start_jump_result;
}


/******************************************************************************/
/* Function:  jump_ttm_check                                                  */
/*                                                                            */
/*! \brief    Core function of JUMP_TTM_CHECK state
 *  \param    void
 *  \return   RETVAL - IN_PROGRESS, READY or ERROR
 *  \remark   Check for Focus, HF, track. Relock Acquisition if needed.
 *            Adjust TTM speed.
 */
/******************************************************************************/

RETVAL jump_ttm_check(void)
{
  RETVAL jump_ttm_check_result;
  t_set_speed_result set_speed_result;

  if ((jump_ttm_check_state != STATE_1) && (!timer_in_progress(SERVO_SAFETY_TIMER)))
  {
    jump_ttm_check_result = JUMP_TTM_CHECK_TIMEOUT_ERROR;
  }
  else
  {
    jump_ttm_check_result = check_servo(CHECK_TTM | CHECK_FOCUS | CHECK_HF | CHECK_TRACKING);
    if (jump_ttm_check_result == OK)
    {
      jump_ttm_check_result = IN_PROGRESS;
      switch (jump_ttm_check_state)
      {
      case STATE_1:
        servo_function_counter = MAX_PLL_RETRIES;
        servo_function_counter_2 = MAX_PLL_RETRIES_2;
        start_timer(SERVO_SAFETY_TIMER, SEEK_PRO_RELOCK_SPEED_TIMEOUT);
        /* fall through */

      case STATE_2:
        if (servo_misc_flags.field.relock_request)
        {
          servo_misc_flags.field.relock_request = 0;
          ACQ_UNLOCKED_GAINS.all = 0x46;
          ACQ_INT_CTRL.field.acq_reset = 1;
          ACQ_INT_CTRL.field.acq_reset = 0;
          ACQ_PLL_CTRL1.field.relock = 1;
          DISABLE_INTERRUPTS();
          servo_acq_flags.field.mode1_subcode = 0;
          servo_acq_flags.field.new_T_subcode = 0;
          servo_acq_flags.field.new_T = 0;
          servo_acq_flags.field.erased_cd_rw = 0;
          ENABLE_INTERRUPTS();
        }
#ifndef ECC_WORKAROUND
        start_timer(SERVO_FUNCTION_TIMER, SEEK_PRO_PLL_RELOCK_TIMEOUT);
        jump_ttm_check_state = STATE_5;
        break;
#else // BBTODO no need we will use only CAV
/* HW060123a - BEGIN */
        if ((CLV == (target_ttm_speed & DISC_MODE))
         && (CDV != (current_ttm_speed & DISC_MODE))
         && ((target_ttm_speed & DISC_SPEED) == (current_ttm_speed & DISC_SPEED)))
        {
          ECC_MODE.field.s_res = 1;
          ECC_MODE.field.s_res = 0;
          OIF_AP_CONTROL_PART_2.field.enable_sample_req = 1;
          event_in[CLV_IRQ_EVENT].event = CLV_IRQ_NO_EVENT;
          start_timer(SERVO_FUNCTION_TIMER, SEEK_PRO_PLL_RELOCK_TIMEOUT);
          jump_ttm_check_state = STATE_3;
        }
        else
        {
          start_timer(SERVO_FUNCTION_TIMER, SEEK_PRO_PLL_RELOCK_TIMEOUT);
          jump_ttm_check_state = STATE_5;
        }
        break;

      case STATE_3:
        /* Wait until CLV buffer becomes empty after the ECC_MODE reset. */
        if (CLV_IRQ_EVENT_UNDERFLOW == event_in[CLV_IRQ_EVENT].event)
        {
          /* Stop pulling data out of CLV buffer. */
          OIF_AP_CONTROL_PART_2.field.enable_sample_req = 0;
          /* Reset clv_buffer_ok, DSP now waits until the CLV reaches a certain level
             (set by clv_buffer_ok_thres) then clv_buffer_ok is set to 1 again and a
             CLV_BUFFER_OK_MBX_INT interrupt is generated. In the corresponding ISR
             the bit AP_CONTROL_PART_2.field.enable_sample_req is set again and data
             is retrieved again from the CLV buffer. */
          dsp_write_xmem(DSP_STATE_ADD, get_clr_clv_buffer_ok(dsp_read_xmem(DSP_STATE_ADD)));
          event_in[DSP_CLV_BUFFER_EVENT].event = CLV_BUFFER_EVENT_NOT_OK;
          jump_ttm_check_state = STATE_4;
        }
        break;

      case STATE_4:
        if (CLV_BUFFER_EVENT_OK == event_in[DSP_CLV_BUFFER_EVENT].event)
        {
          /* CLV buffer is okay again, release the TTM controller from hold-mode
             by resetting jump_mode. */
          OIF_AP_CONTROL_PART_2.field.enable_sample_req = 1;
          start_timer(SERVO_FUNCTION_TIMER, SEEK_PRO_PLL_RELOCK_TIMEOUT);
          jump_ttm_check_state = STATE_5;
        }
        break;
/* HW060123a - END */
#endif

      case STATE_5:
        if (timer_in_progress(SERVO_FUNCTION_TIMER))
        {
          if (servo_acq_flags.field.mode1_subcode)   /* PLL locked */
          {
            ACQ_UNLOCKED_GAINS.all = 0x35;   /* HW050530a */
            servo_startup_flags.field.mode1_found = 1;
            servo_function_counter = MAX_PLL_RETRIES;
            servo_function_counter_2--;
            stop_timer(SERVO_FUNCTION_TIMER);

            if (servo_misc_flags.field.set_speed_request)
            {
              servo_misc_flags.field.set_speed_request = 0;
              set_speed_result = set_speed(target_ttm_speed);
              if (set_speed_result == SET_SPEED_RESULT_DEC_RATIO_CHANGED)
              {
                set_disc_control(DISC_CONTROL_SET_SPEED);
                jump_ttm_check_state = STATE_2;
              }
#ifdef ECC_WORKAROUND
              else if (set_speed_result == SET_SPEED_RESULT_CLV_ENABLED)
              {
                jump_ttm_check_state = STATE_2;
              }
#endif
              else if (servo_misc_flags.field.check_speed_request) 
              {
                servo_misc_flags.field.check_speed_request = 0;
                check_ttm_speed_request();
                jump_ttm_check_state = STATE_6;
              }
              else
              {
                jump_ttm_check_result = OK;
              }
            }
            else
            {
              jump_ttm_check_result = OK;
            }
          }
          else if (servo_acq_flags.field.erased_cd_rw)   /* erased CD-RW */
          {
            ACQ_UNLOCKED_GAINS.all = 0x35;   /* HW050530a */
            stop_timer(SERVO_FUNCTION_TIMER);
            jump_ttm_check_result = ERASED_CD_RW;
          }
          /* else not needed   ((!servo_acq_flags.field.mode1_subcode) &&   (PLL unlocked and */
          /*                    (!servo_acq_flags.field.erased_cd_rw))       no erased CD-RW) */
        }
        else   /* (!timer_in_progress(SERVO_FUNCTION_TIMER)) */
        {
          servo_function_counter--;
          if ((servo_function_counter != 0) && (servo_function_counter_2 != 0))
          {
            set_disc_control(DISC_CONTROL_RECOVER);
            jump_ttm_check_state = STATE_2;
          }
          else
          {
            jump_ttm_check_result = PLL_ERROR;
          }
        }
        break;

      //case STATE_6:
      default:
        if (timer_in_progress(SERVO_ACQ_INT_TIMER))
        {
          if (servo_misc_flags.field.set_speed_request)
          {
            jump_ttm_check_state = STATE_5;
          }
          else
          {
            switch (check_ttm_speed())
            {
            case IN_PROGRESS:
              break;

            case OK:
              jump_ttm_check_result = OK;
              break;

            //case TTM_SPEED_ERROR:
            default:
              jump_ttm_check_result = TTM_SPEED_ERROR;
              break;
            }
          }
        }
        else   /* (!timer_in_progress(SERVO_ACQ_INT_TIMER)) */
        {
          set_disc_control(DISC_CONTROL_RECOVER);
          jump_ttm_check_state = STATE_2;
        }
        break;
      }
    }
    /* else not needed   ((jump_ttm_check_result = check_servo(CHECK_TTM | CHECK_FOCUS | CHECK_HF | CHECK_TRACKING)) == TTM_STOPPED / FOCUS_LOST / HF_LOST / TRACKING_LOST) */
  }
  return jump_ttm_check_result;
}


/******************************************************************************/
/* Function:  access_check                                                    */
/*                                                                            */
/*! \brief    Core function of servo's ACCESS_CHECK state
 *  \param    void
 *  \return   RETVAL - IN_PROGRESS, READY or ERROR
 *  \remark
 */
/******************************************************************************/

RETVAL access_check(void)
{
  RETVAL access_check_result;

  reset_servo_errors();
  servo_startup_flags.field.first_startup_sequence_completed = 1;
  if (servo_seek_flags.field.seek_state == NEW_SEEK_REQUESTED)
  {
    access_check_result = JUMP_REQUEST;
  }
  else if (servo_seek_flags.field.seek_state == SEEK_IN_PROGRESS)
  {
    if ((delta_trk == 0) && (T_actual < target_T))
    {
      access_check_result = OK;
    }
    else
    {
      access_check_result = check_access_msf();
    }

    if (JUMP_REQUEST == access_check_result)   /* BB050714b */
    {
      if (corrective_jumps_counter)
      {
        corrective_jumps_counter--;
      }
      else   /* (!corrective_jumps_counter) */
      {
        access_check_result = SEEK_ERROR;
        DEBUG_SERVO(("corr_jumps_cntr ", 1, 1,
                     (SEEK_PRO_MAX_CORRECTIVE_JUMPS - corrective_jumps_counter)));
      }
    }
    else   // (OK == access_check_result)   /* BB050714b */
    {
      servo_seek_flags.field.seek_cmd_executed = 0;   /* BB050411a */
      servo_seek_flags.field.seek_state = SEEK_COMPLETED;
      DEBUG_SERVO(("corr_jumps_cntr ", 1, 1,
                   (SEEK_PRO_MAX_CORRECTIVE_JUMPS - corrective_jumps_counter)));
    }
  }
  else   /* (servo_seek_flags.field.seek_state == NO_SEEK_REQUESTED (i.e. SEEK_COMPLETED)) */
  {
    access_check_result = OK;
  }

  DEBUG_SERVO(("access_check()", 1, 1, access_check_result));
  return access_check_result;
}


/******************************************************************************/
/* Function:   store_jump_to_current_position                                 */
/*                                                                            */
/*! \brief    stores a seek request to the last played time
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void store_jump_to_current_position(void)
{
  if (servo_active_flags.field.servo_mode == PLAY_MODE)
  {
    if (previous_T != 0)
    {
      target_T = previous_T + 1;
      previous_T = 0;
    }
    servo_seek_flags.field.seek_mode = SEEK_TARGET;
    servo_seek_flags.field.seek_state = NEW_SEEK_REQUESTED;
  }
  else if (servo_active_flags.field.servo_mode == PAUSE_MODE)
  {
    previous_T = 0;
    servo_seek_flags.field.seek_mode = SEEK_TARGET;
    servo_seek_flags.field.seek_state = NEW_SEEK_REQUESTED;
  }
}


/******************************************************************************/
/* Function:  active_check                                                    */
/*                                                                            */
/*! \brief    Core function of servo's ACTIVE_CHECK state
 *  \param    void
 *  \return   RETVAL - IN_PROGRESS, READY or ERROR
 *  \remark
 */
/******************************************************************************/

RETVAL active_check(void)
{
  RETVAL active_check_result;
#ifdef APM_PICKUP
  if ((active_check_result = check_servo(CHECK_TTM | CHECK_FOCUS | CHECK_HF | CHECK_TRACKING)) == OK)   /* MR050523b, added CHECK_TTM. */
#else
  if ((active_check_result = check_servo(CHECK_FOCUS | CHECK_HF | CHECK_TRACKING)) == OK)
#endif
  {
    if (timer_in_progress(SERVO_ACQ_INT_TIMER))
    {
      if (servo_seek_flags.field.seek_state == NEW_SEEK_REQUESTED)
      {
        active_check_result = JUMP_REQUEST;
      }
      else if (servo_misc_flags.field.set_speed_request)
      {
        active_check_result = SET_SPEED_REQUEST;
      }
      else
      {
        active_check_result = check_active_msf();
      }
    }
    else   /* (!timer_in_progress(SERVO_ACQ_INT_TIMER)) */
    {
      active_check_result = PLL_UNLOCKED;
      servo_recover_flags.field.active_check_recover_executed = 1;
      store_jump_to_current_position();
    }
  }
  else   /* ((active_check_result = check_servo(CHECK_TTM | CHECK_FOCUS | CHECK_HF | CHECK_TRACKING)) == TTM_STOPPED / FOCUS_LOST / HF_LOST / TRACKING_LOST) */
  {
    servo_recover_flags.field.active_check_recover_executed = 1;
    store_jump_to_current_position();
  }

  return active_check_result;
}
#endif // HAVE_CD_MECHA