srvttm.c

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

        || (TTM_CALLER_SPEED_RESET == ttm_caller))
  {
    servo_ttm_flags.field.ttm_speed_ok = 0;
  }

  switch (ttm_fsm_state)
  {
  case TTM_STATE_IDLE:
    break;

  case TTM_STATE_START_KICK:
    servo_ttm_flags.field.ttm_speed_error = 0;
    if (servo_recover_flags.field.ttm_recover_active)
    {
      current_ttm_speed = CDV | CDV_1X_IN_DISC;
      dsp_write_xmem(DISC_MODE_ADD, CDV_MODE);   /* Set controller to CDV mode; speed is prepared in start_ttm() */
      start_timer(SERVO_TTM_TIMER, TTM_RECOVER_TIMEOUT_1);
      ttm_event = set_ttm_state(TTM_STATE_RECOVER_KICK);
    }
    else
    {
      dsp_write_xmem(DISC_MODE_ADD, KICK_MODE);
      dsp_write_xmem(SPINDLE_KICK_ADD, TTM_PRO_SPINDLE_KICK_START);
      start_timer(SERVO_TTM_TIMER, TTM_PRO_KICK_TIME_START);
      ttm_event = set_ttm_state(TTM_STATE_WAIT_KICK);
    }
    break;

  case TTM_STATE_RECOVER_KICK:
    if (!timer_in_progress(SERVO_TTM_TIMER))
    {
      start_timer(SERVO_TTM_TIMER, TTM_RECOVER_TIMEOUT_2);
      sledge_condition = SLEDGE_CONDITION_STORE_DELTA_TRK;
      ttm_event = set_ttm_state(TTM_STATE_RECOVER_CHECK);
    }
    break;

  case TTM_STATE_RECOVER_CHECK:
    if (TTM_CALLER_DELTA_TRK_OK == ttm_caller)
    {
      if (timer_in_progress(SERVO_TTM_TIMER))
      {
        start_timer(SERVO_TTM_TIMER, TTM_PRO_WAIT_TIME_START);
        ttm_event = set_ttm_state(TTM_STATE_WAIT_SPIN_UP);
      }
      else
      {
        dsp_write_xmem(DISC_MODE_ADD, KICK_MODE);
        dsp_write_xmem(SPINDLE_KICK_ADD, TTM_PRO_SPINDLE_KICK_START);
        start_timer(SERVO_TTM_TIMER, TTM_PRO_KICK_TIME_START);
        ttm_event = set_ttm_state(TTM_STATE_WAIT_KICK);
      }
    }
    break;

  case TTM_STATE_WAIT_KICK:
    if (!timer_in_progress(SERVO_TTM_TIMER))
    {
      current_ttm_speed = CDV | CDV_1X_IN_DISC;
      dsp_write_xmem(DISC_MODE_ADD, CDV_MODE);   /* Set controller to CDV mode; speed is prepared in start_ttm() */
      start_timer(SERVO_TTM_TIMER, TTM_PRO_WAIT_TIME_START);
      ttm_event = set_ttm_state(TTM_STATE_WAIT_SPIN_UP);
    }
    break;

  case TTM_STATE_WAIT_SPIN_UP:
    if (!timer_in_progress(SERVO_TTM_TIMER))
    {
      ttm_event = set_ttm_state(TTM_STATE_ACTIVE);
    }
    break;

  case TTM_STATE_CHECK_ON_SPEED:
    if (timer_in_progress(SERVO_TTM_TIMER))
    {
      if (ttm_speed_ok())
      {
        stop_timer(SERVO_TTM_TIMER);
        ttm_event = set_ttm_state(TTM_STATE_ACTIVE);
      }
    }
    else
    {
      servo_ttm_flags.field.ttm_speed_error = 1;
      ttm_event = set_ttm_state(TTM_STATE_ACTIVE);
    }
    break;

  case TTM_STATE_ACTIVE:
    break;

  case TTM_STATE_START_BRAKE:
    dsp_write_xmem(SPINDLE_KICK_ADD, (uint16)TTM_PRO_SPINDLE_KICK_BRAKE);
    dsp_write_xmem(DISC_MODE_ADD, KICK_MODE);

    if (((current_ttm_speed & DISC_MODE) == CDV)
     || ((current_ttm_speed & DISC_MODE) == CDV_PREPARED))
    {
      /* only CDV_1X_IN_DISC is used */
      start_timer(SERVO_TTM_TIMER, brake_time_cdv_1x_in);
    }
    else   //   ((current_ttm_speed & DISC_MODE) == CLV)
           // || (current_ttm_speed & DISC_MODE) == SCP_CLV))
    {
      x_factor = (uint8)(current_ttm_speed & DISC_SPEED);
      start_timer(SERVO_TTM_TIMER, ((TTM_PRO_KICK_TIME_BRAKE_GAIN_POSITION << 12) / (sector_2_trk(T_actual) - rate_jumped_tracks)) * x_factor * (freq_1T >> 4) / target_freq_1T);
    }

    ttm_event = set_ttm_state(TTM_STATE_WAIT_BRAKE);
    break;

  case TTM_STATE_WAIT_BRAKE:
    if (!timer_in_progress(SERVO_TTM_TIMER))
    {
      dsp_write_xmem(SPINDLE_KICK_ADD, TTM_PRO_SPINDLE_KICK_IDLE);
      ttm_event = set_ttm_state(TTM_STATE_WAIT_SPIN_DOWN);
      if (((current_ttm_speed & DISC_MODE) == CDV)
        || (current_ttm_speed & CDV_AUX_FLAG))
      {
        start_timer(SERVO_TTM_TIMER, TTM_PRO_WAIT_TIME_BRAKE_CDV);
      }
      else
      {
        start_timer(SERVO_TTM_TIMER, TTM_PRO_WAIT_TIME_BRAKE_CLV);
      }
    }
    break;

  //case TTM_STATE_WAIT_SPIN_DOWN:
  default:
    if (!timer_in_progress(SERVO_TTM_TIMER))
    {
      ttm_event = set_ttm_state(TTM_STATE_IDLE);
    }
    break;
  }
  
  return ttm_event;
}


/******************************************************************************/
/* Function:  ttm_fsm_call                                                    */
/*                                                                            */
/*! \brief    external call to ttm_fsm
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void ttm_fsm_call(t_ttm_caller ttm_caller)
{
  t_ttm_event ttm_event;

  event_disable_scheduling();
  ttm_event = ttm_fsm(ttm_caller);
  if (ttm_caller < TTM_CALLER_MAX_CMD)
  {
    if (TTM_NO_EVENT != ttm_event)
    {
      event_pending[TTM_EVENT].event = TTM_NO_EVENT;
      event_in[TTM_EVENT].event = ttm_event;
    }
  }
  else
  {
    set_ttm_event(ttm_event);
    event_out_shedule(TTM_EVENT);
  }
  event_enable_scheduling();
}


/******************************************************************************/
/* Function:  set_speed                                                       */
/*                                                                            */
/*! \brief    Reprogramming controller and register settings for desired speed
 *  \param    uint8 speed
 *  \return   uint8 result - 1 if DEC_RATIO is modified, 0 otherwise
 *  \remark   
 */
/******************************************************************************/

t_set_speed_result set_speed(uint8 speed)
{
  t_set_speed_result set_speed_result;
  uint8 previous_ttm_speed;
  uint8 decimation_ratio, gain_shift;

  previous_ttm_speed = current_ttm_speed;
  
  if (speed != CDV_PREPARED)
  {
    if (speed != (CDV | CDV_AUX))
    {
      current_ttm_speed = speed;
    }
    else
    {
      current_ttm_speed |= CDV_AUX_FLAG;
    }
  }

  DEBUG_SERVO (("set_speed ", 1, 2, speed, current_ttm_speed));

  ttm_fsm_call(TTM_CALLER_SPEED_RESET);

  dsp_write_xmem(DISC_MODE_ADD, HOLD_MODE);

  switch (speed & DISC_MODE)
  {
  case CLV:
  case SCP_CLV:
    switch (speed & DISC_SPEED)
    {
    case CLV_1X:
      target_freq_1T = FREQ_1T_CLV_1X;
      if ((previous_ttm_speed == (CDV | CDV_1X_IN_DISC))
       && (T_actual > CDT_20MIN))
      {
        decimation_ratio = 1;
        gain_shift = 1;
      }
      else
      { 
        decimation_ratio = 2;
        gain_shift = 0;
      }
      break;

    case CLV_2X:
      target_freq_1T = FREQ_1T_CLV_2X;
      decimation_ratio = 1;
      gain_shift = 1;
      break;

    default:
      break;
    }

    target_freq_1T = target_freq_1T >> (2 - decimation_ratio);

    dsp_write_ymem(COEFF_CLV_ADD + 0, TTM_PRO_CLV_CONTROLLER_COEFF[0] + gain_shift);
    dsp_write_ymem(COEFF_CLV_ADD + 1, TTM_PRO_CLV_CONTROLLER_COEFF[1]);
    dsp_write_ymem(COEFF_CLV_ADD + 5, TTM_PRO_CLV_CONTROLLER_COEFF[5] + gain_shift);
    dsp_write_ymem(COEFF_CLV_ADD + 6, TTM_PRO_CLV_CONTROLLER_COEFF[6]);
    
    if (SCP_CLV != (speed & DISC_MODE))
    {
      dsp_write_ymem(COEFF_CLV_ADD + 2, 0x0000);
      dsp_write_ymem(COEFF_CLV_ADD + 3, 0x0000);
      dsp_write_ymem(COEFF_CLV_ADD + 7, TTM_PRO_CLV_CONTROLLER_COEFF[7]);
      dsp_write_ymem(COEFF_CLV_ADD + 8, TTM_PRO_CLV_CONTROLLER_COEFF[8]);
      dsp_write_ymem(COEFF_CLV_ADD + 9, TTM_PRO_CLV_CONTROLLER_COEFF[9]);
      dsp_write_xmem(CLV_PHASE_ERR_MAX_ADD, TTM_PRO_CLV_PHASE_ERR_MAX);
    }
    else
    {
      if (CDinfo & DISC_8CM)
      {
        dsp_write_ymem(COEFF_CLV_ADD + 2, TTM_PRO_CLV_CONTROLLER_COEFF[2 + 8]);
        dsp_write_ymem(COEFF_CLV_ADD + 3, TTM_PRO_CLV_CONTROLLER_COEFF[3 + 8]);
      }
      else
      {
        dsp_write_ymem(COEFF_CLV_ADD + 2, TTM_PRO_CLV_CONTROLLER_COEFF[2]);
        dsp_write_ymem(COEFF_CLV_ADD + 3, TTM_PRO_CLV_CONTROLLER_COEFF[3]);
      }
      dsp_write_ymem(COEFF_CLV_ADD + 7, 0x0000);
      dsp_write_ymem(COEFF_CLV_ADD + 8, 0x0000);
      dsp_write_ymem(COEFF_CLV_ADD + 9, 0x0000);
      dsp_write_xmem(CLV_PHASE_ERR_MAX_ADD, 0x7FFF);
    }

    if (CDinfo & DISC_8CM)
    {
      dsp_write_xmem(SPDL_LIMIT_MIN_ADD, (uint16)TTM_PRO_SPINDLE_SATURATION_MIN_8CM);
      dsp_write_xmem(SPDL_LIMIT_MAX_ADD, (uint16)TTM_PRO_SPINDLE_SATURATION_MAX_8CM);
      dsp_write_ymem(COEFF_CLV_ADD + 4, TTM_PRO_CLV_CONTROLLER_COEFF[4 + 8]);
    }
    else
    {
      dsp_write_xmem(SPDL_LIMIT_MIN_ADD, (uint16)TTM_PRO_SPINDLE_SATURATION_MIN_12CM);
      dsp_write_xmem(SPDL_LIMIT_MAX_ADD, (uint16)TTM_PRO_SPINDLE_SATURATION_MAX_12CM);
      dsp_write_ymem(COEFF_CLV_ADD + 4, TTM_PRO_CLV_CONTROLLER_COEFF[4]);
    }

    dsp_write_xmem(TTM_DOWNSAMPLING_ADD, TTM_PRO_DOWNSAMPLING_FACTOR);
    dsp_write_xmem(TARGET_P1T_ADD, target_freq_1T);
    dsp_write_xmem(DISC_MODE_ADD, CLV_MODE);
    break;

  //case CDV:
  //case CDV_PREPARED:
  default:
    switch (speed & DISC_SPEED)
    {
    case CDV_1X_IN_DISC:
      decimation_ratio = 1;
      dsp_write_xmem(TARGET_P1T_ADD, TTM_PRO_SPINDLE_KICK_CDV_1X_IN);
      break;
        
    //case CDV_AUX:
    default:
      decimation_ratio = ACQ_CHA_CTRL1.field.dec_ratio;
      dsp_write_xmem(TARGET_P1T_ADD, (uint16)aux_ttm_input);
      break;    
    }

    if (CDV_PREPARED != (speed & DISC_MODE))
    {
      dsp_write_xmem(DISC_MODE_ADD, CDV_MODE);
    }  
    break;
  }

  if (ACQ_CHA_CTRL1.field.dec_ratio != decimation_ratio)
  {
    ACQ_CHA_CTRL1.field.dec_ratio = decimation_ratio;
    set_speed_result = SET_SPEED_RESULT_DEC_RATIO_CHANGED;
  }
#ifdef ECC_WORKAROUND
  else if (((current_ttm_speed & DISC_MODE) == CLV)
        && ((previous_ttm_speed & DISC_MODE) != CLV))
  {
    set_speed_result = SET_SPEED_RESULT_CLV_ENABLED;
  }
#endif
  else
  {
    set_speed_result = SET_SPEED_RESULT_OK;
  }

#if (DEBUG_INCLUDE_PCDEB == 1)
  oif_init_debug();
#endif

  return set_speed_result;
}


/******************************************************************************/
/* Function:  set_disc_control                                                */
/*                                                                            */
/*! \brief    Selection of disc control strategy when PLL is unlocked
 *  \param    uint8 disc_control_mode
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void set_disc_control(uint8 disc_control_mode)
{
  uint8 x_factor;
  sint16 prev_aux_ttm_input;
  sint32 temp_aux_ttm_input;
  uint16 recover_track;
  
  servo_misc_flags.field.relock_request = 1;

  if ((((current_ttm_speed & DISC_MODE) == CLV) 
    || ((current_ttm_speed & DISC_MODE) == SCP_CLV))
   && (servo_startup_flags.field.ttm_started))
  {
    x_factor = (uint8)(current_ttm_speed & DISC_SPEED);
    prev_aux_ttm_input = aux_ttm_input;

    switch (disc_control_mode)
    {
    case DISC_CONTROL_RECOVER:
    case DISC_CONTROL_SET_SPEED:
      if (servo_acq_flags.field.new_T)
      {
        recover_track = sector_2_trk(T_actual);
      }
      else
      {
        recover_track = sector_2_trk(CDT_20MIN); 
      }

      temp_aux_ttm_input = TTM_PRO_SPINDLE_KICK_CDV_AUX_OFFSET
                         + ((TTM_PRO_SPINDLE_KICK_CDV_AUX_GAIN_POSITION << 14) / recover_track) * x_factor;
      break;

    case DISC_CONTROL_LONG_JUMP:
      if (servo_seek_flags.field.starting_trk_unknown)
      {
        starting_trk = sector_2_trk(T_actual);
      }

      temp_aux_ttm_input = TTM_PRO_SPINDLE_KICK_CDV_AUX_OFFSET 
                         + (((TTM_PRO_SPINDLE_KICK_CDV_AUX_GAIN_POSITION << 14) / starting_trk)
                          - (sign(delta_trk) * (((TTM_PRO_SPINDLE_KICK_CDV_AUX_GAIN_JUMP
                                               + ((TTM_PRO_SPINDLE_KICK_CDV_AUX_GAIN_EXTRA * absi(delta_trk)) >> 16) << 14)
                                                            / ((starting_trk * target_trk) >> 16))))) * x_factor;
      break;
 
    //case DISC_CONTROL_SHORT_JUMP:
    default:
      if (servo_seek_flags.field.starting_trk_unknown)
      {
        starting_trk = sector_2_trk(T_actual);
      }

      temp_aux_ttm_input = TTM_PRO_SPINDLE_KICK_CDV_AUX_OFFSET 
                         + ((TTM_PRO_SPINDLE_KICK_CDV_AUX_GAIN_POSITION << 14) / starting_trk) * x_factor;
      break;
    }

    if (temp_aux_ttm_input > TTM_PRO_SPINDLE_SATURATION_MAX)
    {
      aux_ttm_input = TTM_PRO_SPINDLE_SATURATION_MAX;
    }
    else if (temp_aux_ttm_input < TTM_PRO_SPINDLE_SATURATION_MIN)
    {
      aux_ttm_input = TTM_PRO_SPINDLE_SATURATION_MIN;
    }
    else
    {
      aux_ttm_input = temp_aux_ttm_input;
    }

    servo_misc_flags.field.set_speed_request = 1;

    if ((!(current_ttm_speed & CDV_AUX_FLAG))
     || (aux_ttm_input != prev_aux_ttm_input))
    {
      set_speed(CDV | CDV_AUX);
    }

    if ((disc_control_mode != DISC_CONTROL_SHORT_JUMP)
     || (absi(delta_trk) >= SEEK_PRO_SHORT_VERYSHORT_JUMP_THS))
    {
      servo_misc_flags.field.check_speed_request = 1;
    }
  }
}


#ifdef ECC_WORKAROUND

#define set_clv_irq_event(e)        do{event_out[CLV_IRQ_EVENT].event = e;}while (0)

void clv_isr_irq(void)
{
  set_clv_irq_event(CLV_IRQ_NO_EVENT);

  if (CLV_LEVEL_POINTER.field.overflow)
  {
    set_clv_irq_event(CLV_IRQ_EVENT_OVERFLOW);
  }

  if (CLV_LEVEL_POINTER.field.underflow)
  {
    set_clv_irq_event(CLV_IRQ_EVENT_UNDERFLOW);
  }

  event_disable_scheduling();
  event_out_shedule(CLV_IRQ_EVENT);
  event_enable_scheduling();
}

#endif