srvttm.c

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

/**************************************************
 *
 * srvttm.c
 *
 * CVS ID:   $Id: srvttm.c,v 1.17 2007/09/26 15:11:12 dellorto Exp $
 * Author:   Fabio Dell'Orto [FD] - STM
 * Date:     $Date: 2007/09/26 15:11:12 $
 * Revision: $Revision: 1.17 $
 *
 * Description:
 *
 *
 ***************************************************
 *
 * COPYRIGHT (C) ST Microelectronics  2005
 *            All Rights Reserved
 *
 ***************************************************
 *  \brief          Turntable Motor management procedures
 *
 *  \par            Change History:
 *
 ***************************************************
 *
 * STM CVS Log:
 *
 * $Log: srvttm.c,v $
 * Revision 1.17  2007/09/26 15:11:12  dellorto
 * improvement to make ttm recover safe
 *
 * Revision 1.16  2007/08/14 15:29:57  dellorto
 * multiple mechanisms
 *
 * Revision 1.15  2007/04/11 14:21:16  belardi
 * Integration of HAVE_CD_MECHA modification by [GP]
 *
 * Revision 1.14  2007/03/16 14:25:09  dellorto
 * used new profiles
 * ttm recover improved
 * added option to hold ttn during short jumps
 * fixed sign of rate jumped tracks
 *
 * Revision 1.13  2006/11/20 13:59:03  marcucci
 * Removed seting of i2s_ratio in set_speed command for Audio Config Command
 *
 * Revision 1.12  2006/10/09 15:16:19  dellorto
 * modified start_ttm() to support improved TTM recover
 *
 * Revision 1.11  2006/09/18 09:55:26  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.10  2006/09/18 09:25:48  belardi
 * Added Log CVS keyword into file header
 *
 *
 ***************************************************/

#include "gendef.h"
#include "hwreg.h"
#include "osal.h"
#include "srvinc.h"

#if (DEBUG_INCLUDE_PCDEB == 1)
 #include "dbgdef.h"
 #include "dbgext.h"
#endif


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

t_ttm_state ttm_fsm_state;   /* debug only */
sint16 aux_ttm_input;

uint32 freq_1T;
uint16 target_freq_1T;
uint8 target_ttm_speed;
uint8 current_ttm_speed;

SERVO_TTM_FLAGS_UNION servo_ttm_flags;


/*-------------------------- Function implementation -------------------------*/

/******************************************************************************/
/* Function:  ttm_speed_ok                                                    */
/*                                                                            */
/*! \brief    Check if actual TTM speed inside the threshold for the
              chosen speed setting
 *  \param    void
 *  \return   uint8, 0 for FALSE, 1 for OK
 *  \remark
 */
/******************************************************************************/

t_bool ttm_speed_ok(void)
{
  return (t_bool)(0 != servo_ttm_flags.field.ttm_speed_ok);
}


/******************************************************************************/
/* Function:  check_ttm_braking                                               */
/*                                                                            */
/*! \brief    Wait until fsm reaches target state. Then report OK or ERROR
 *  \param    void
 *  \return   uint8, OK, IN_PROGRESS or STOP_TTM_ERROR
 *  \remark
 */
/******************************************************************************/

RETVAL check_ttm_braking(void)
{
  if (TTM_EVENT_STOPPED == (t_ttm_event)event_in[TTM_EVENT].event)
  {
    return (OK);
  }
  else
  {
    return (IN_PROGRESS);
  }
}


/******************************************************************************/
/* Function:  check_ttm_speed                                                 */
/*                                                                            */
/*! \brief    Wait until fsm target state is reached. Then report OK or ERROR
 *  \param    void
 *  \return   uint8, OK, IN_PROGRESS or TTM_SPEED_ERROR
 *  \remark
 */
/******************************************************************************/

RETVAL check_ttm_speed(void)
{
  if (TTM_EVENT_SPEED_ERROR == (t_ttm_event)event_in[TTM_EVENT].event)
  {
    return (TTM_SPEED_ERROR);
  }
  else if (TTM_EVENT_ON_SPEED == (t_ttm_event)event_in[TTM_EVENT].event)
  {
    return (OK);
  }
  else
  {
    return (IN_PROGRESS);
  }
}


/******************************************************************************/
/* Function:  set_ttm_state                                                   */
/*                                                                            */
/*! \brief    Set ttm state and report ttm event
 *  \param    uint8 ttm_state
 *  \return   t_ttm_event, ttm event
 *  \remark
 */
/******************************************************************************/

t_ttm_event set_ttm_state(t_ttm_state ttm_state)
{
  t_ttm_event ttm_event;

  ttm_fsm_state = ttm_state;

  switch (ttm_state)
  {
  case TTM_STATE_WAIT_KICK:
    ttm_event = TTM_EVENT_STARTING;
    DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM starting", 4, 0));
    break;

  case TTM_STATE_WAIT_BRAKE:
    ttm_event = TTM_EVENT_BRAKING;
    DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM braking", 4, 0));
    break;

  case TTM_STATE_CHECK_ON_SPEED:
    ttm_event = TTM_EVENT_SPEED_CHANGING;
    DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM speed changing", 4, 0));
    break;

  case TTM_STATE_IDLE:
    ttm_event = TTM_EVENT_STOPPED;
    DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM stopped", 4, 0));
    break;

  case TTM_STATE_ACTIVE:
    if (servo_ttm_flags.field.ttm_speed_error)
    {
      ttm_event = TTM_EVENT_SPEED_ERROR;
      DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM speed error", 4, 0));
    }
    else
    {
      ttm_event = TTM_EVENT_ON_SPEED;
      DEBUG_SERVO_TTM_EVENT(("TTM_EVENT: TTM on speed", 4, 0));
    }
    break;

  //case TTM_STATE_START_KICK:
  //case TTM_STATE_WAIT_SPIN_UP:
  //case TTM_STATE_START_BRAKE:
  //case TTM_STATE_WAIT_SPIN_DOWN:
  default:
    ttm_event = TTM_NO_EVENT;
    break;
  }

  DEBUG_SERVO_TTM_STATE(("TTM_STATE:", 1, 1, ttm_fsm_state));

  return ttm_event;
}


/******************************************************************************/
/* Function:  kick_ttm                                                        */
/*                                                                            */
/*! \brief    Activate TTM state machine, execute startup sequence
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void kick_ttm(void)
{
  ttm_fsm_call(TTM_CALLER_KICK_CMD);
}


/******************************************************************************/
/* Function:  brake_ttm                                                       */
/*                                                                            */
/*! \brief    Activate TTM state machine, execute brake sequence
 *  \param    void
 *  \return   void
 *  \remark   set FSM to TTM_STATE_START_BRAKE
 */
/******************************************************************************/

void brake_ttm(void)
{
  ttm_fsm_call(TTM_CALLER_BRAKE_CMD);
}


/******************************************************************************/
/* Function:  check_ttm_speed_request                                         */
/*                                                                            */
/*! \brief    Set timeout and set fsm into CHECK_ON_SPEED
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void check_ttm_speed_request(void)
{
  ttm_fsm_call(TTM_CALLER_CHECK_SPEED_CMD);
}


/******************************************************************************/
/* Function:  start_ttm                                                       */
/*                                                                            */
/*! \brief    Start TTM handler of CAV
 *  \param    void
 *  \return   uint8, IN_PROGRESS, OK or TTM_SPEED_ERROR
 *  \remark   assumption: focus loop has already been closed
 */
/******************************************************************************/

RETVAL start_ttm(void)
{
  RETVAL start_ttm_result;

  if ((start_ttm_state != STATE_1) && (!timer_in_progress(SERVO_SAFETY_TIMER)))
  {
    start_ttm_result = START_TTM_TIMEOUT_ERROR;	
  }
  else
  {
    start_ttm_result = check_servo(CHECK_FOCUS);
    if (start_ttm_result == OK)
    {
      start_ttm_result = IN_PROGRESS;

      switch (start_ttm_state)
      {
      case STATE_1:
        start_timer(SERVO_SAFETY_TIMER, TTM_PRO_START_TIMEOUT);
        if ((servo_startup_flags.field.ttm_started) && (!servo_recover_flags.field.ttm_recover_active))
        {
          start_timer(SERVO_FUNCTION_TIMER, TTM_PRO_HF_PRESENCE_TIMEOUT);
          start_ttm_state = STATE_3;
        }
        else   /* ((!servo_startup_flags.field.ttm_started) || (servo_recover_flags.field.ttm_recover_active)) */
        {
          set_speed(CDV_PREPARED | CDV_1X_IN_DISC);   /* prepare the speed used after the kick */
          kick_ttm();
          start_ttm_state = STATE_2;
        }
        break;

      case STATE_2:
        switch (check_ttm_speed())
        {
        case IN_PROGRESS:
          break;
  
        case OK:
          servo_startup_flags.field.ttm_started = 1;
          servo_recover_flags.field.ttm_recover_active = 0;
          servo_misc_flags.field.relock_request = 1;
          servo_misc_flags.field.set_speed_request = 1;
          servo_misc_flags.field.check_speed_request = 1;
          start_timer(SERVO_FUNCTION_TIMER, TTM_PRO_HF_PRESENCE_TIMEOUT);
          start_ttm_state = STATE_3;
          break;

        //case TTM_SPEED_ERROR:
        default:
          start_ttm_result = TTM_SPEED_ERROR;
          break;
        }
        break;

      //case STATE_3:
      default:
        if (timer_in_progress(SERVO_FUNCTION_TIMER))
        {
          if (check_servo(CHECK_HF) == OK)
          {
            servo_startup_flags.field.hf_found = 1;
            servo_recover_flags.field.hf_recover_mode = HF_PRESENT_IN_CURRENT_POSITION;
            stop_timer(SERVO_FUNCTION_TIMER);
            if (0 != servo_startup_flags.field.fe_adjust_done)
            {
              start_ttm_result = OK;
            }
            else
            {
              start_ttm_result = FE_ADJUST_REQUEST;
            }
          }
          /* else not needed   (check_servo(CHECK_HF) != OK) */
        }
        else   /* (!timer_in_progress(SERVO_FUNCTION_TIMER)) */
        {
          if (!servo_startup_flags.field.hf_found)
          {
            start_ttm_result = HF_SEARCH_AFTER_HF_NOT_FOUND;
          }
          else
          {
            start_ttm_result = HF_NOT_FOUND;
          }
        }
        break;
      }
    }
    /* else not needed   (check_servo(CHECK_FOCUS) != OK) */
  }

  return start_ttm_result;
}


/******************************************************************************/
/* Function:  prepare_ttm_for_recover                                         */
/*                                                                            */
/*! \brief    switches off ttm before dedicated recovery
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void prepare_ttm_for_recover(void)
{
  ttm_fsm_call(TTM_CALLER_RECOVER_CMD);
}


/******************************************************************************/
/* Function:  init_ttm_fsm                                                    */
/*                                                                            */
/*! \brief    Initializer for the ttm state machine.
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void init_ttm_fsm(void)
{
  ttm_fsm_state = TTM_STATE_IDLE;
  event_in[TTM_EVENT].event = TTM_EVENT_STOPPED;
}


/******************************************************************************/
/* Function:  ttm_fsm                                                         */
/*                                                                            */
/*! \brief    TTM state machine. Interface
 *  \param    void
 *  \return   void
 *  \remark   ttm_fsm() is called from servo_fsm. 2 stable states, 1 and 6.
 *            STATE_1 is TTM stopped, STATE_6 is TTM on speed.
 *            When set from 1 to 2 TTM is accelerated. Final state is STATE_6
 *            When set from 6 to 7 TTM is braked. Final state is STATE_1
 */
/******************************************************************************/

#define TTM_RECOVER_TIMEOUT_1   T100ms
#define TTM_RECOVER_TIMEOUT_2   T30ms

t_ttm_event ttm_fsm(t_ttm_caller ttm_caller)
{
  t_ttm_event ttm_event = TTM_NO_EVENT;
  OSAL_TIME_t brake_time_cdv_1x_in;
  uint8 x_factor;

  if (TTM_CALLER_KICK_CMD == ttm_caller)
  {
    if (!IS_TTM_MOVING(ttm_fsm_state))
    {
      ttm_event = set_ttm_state(TTM_STATE_START_KICK);
    }
  }
  else if (TTM_CALLER_BRAKE_CMD == ttm_caller)
  {
    if (IS_TTM_MOVING(ttm_fsm_state))
    {
      if (TTM_STATE_WAIT_KICK == ttm_fsm_state)
      {
        brake_time_cdv_1x_in = (TTM_PRO_KICK_TIME_START - get_timer(SERVO_TTM_TIMER)) * TTM_PRO_KICK_TIME_BRAKE_CDV_1X_IN / TTM_PRO_KICK_TIME_START;
      }
      else
      {
        brake_time_cdv_1x_in = TTM_PRO_KICK_TIME_BRAKE_CDV_1X_IN;
      }

      ttm_event = set_ttm_state(TTM_STATE_START_BRAKE);
    }
  }
  else if (TTM_CALLER_CHECK_SPEED_CMD == ttm_caller)
  {
    start_timer(SERVO_TTM_TIMER, TTM_PRO_SPEED_TIMEOUT);
    servo_ttm_flags.field.ttm_speed_error = 0;
    ttm_event = set_ttm_state(TTM_STATE_CHECK_ON_SPEED);
  }
  else if (TTM_CALLER_RECOVER_CMD == ttm_caller)
  {
    dsp_write_xmem(SPINDLE_KICK_ADD, TTM_PRO_SPINDLE_KICK_IDLE);
    dsp_write_xmem(DISC_MODE_ADD, KICK_MODE);
    ttm_event = set_ttm_state(TTM_STATE_IDLE);
  }
  else if (TTM_CALLER_DSP_SPEED_OK == ttm_caller)
  {
    servo_ttm_flags.field.ttm_speed_ok = 1;
  }
  else if ((TTM_CALLER_DSP_SPEED_NOT_OK == ttm_caller)