srvchn.c

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

  }
  else
    // ( (servo_seek_flags.field.seek_mode == JUMP_TRACKS) ||
    //  ((servo_seek_flags.field.seek_mode == JUMP_TARGET_1) && (!servo_seek_flags.field.from_leadin_to_target)) ||
    //  ((servo_seek_flags.field.seek_mode == JUMP_TARGET_PLUS_TRACKS) && (!servo_seek_flags.field.from_leadin_to_target)))
  {
    check_access_msf_result = OK;
  }

  return check_access_msf_result;
}


/******************************************************************************/
/* Function:  update_subcode_events                                           */
/*                                                                            */
/*! \brief
 *  \param    void
 *  \return   void
 *
 *  \remark
 */
/******************************************************************************/

void update_subcode_events(t_bool endof_seek)
{
  /* subcode event is already copied from acquisition in servo_fsm() if needed
     we need only to update it */

  if (NO_EVENT != event_out[SERVO_SUBCODE_EVENT].event)
  {
    tQsubcode_event *psubcode_event = (tQsubcode_event *) event_out[SERVO_SUBCODE_EVENT].pevent;

    if (endof_seek)
    {
      psubcode_event->event_type |= SERVO_EVENT_SUBCODE_END_OF_SEEK;
    }

    if (servo_recover_flags.field.active_check_recover_executed)
    {
      servo_recover_flags.field.active_check_recover_executed = 0;
      psubcode_event->event_type |= SERVO_EVENT_SUBCODE_AFTER_RECOVER;
    }
  }
}


/******************************************************************************/
/* Function:  compare_msf_te                                                  */
/*                                                                            */
/*! \brief    compare target MSF with endplay MSF
 *  \param    void
 *  \return   int8
 *            0 => msf1 == msf2, positive => msf1 > msf2, negative => msf1 < msf2
 *
 *  \remark
 */
/******************************************************************************/

int32 compare_msf_te(void)
{
  return (int32) target_T - (int32) endplay_T;
}


/******************************************************************************/
/* Function:  compare_msf_ae                                                  */
/*                                                                            */
/*! \brief    compare actual MSF with endplay MSF
 *  \param    void
 *  \return   int8
 *            0 => msf1 == msf2, positive => msf1 > msf2, negative => msf1 < msf2
 *
 *  \remark
 */
/******************************************************************************/

int32 compare_msf_ae(void)
{
  return ((int32) T_actual - (int32) endplay_T);
}


/******************************************************************************/
/* Function:  compare_msf_at                                                  */
/*                                                                            */
/*! \brief    compare actual MSF with target MSF
 *  \param    void
 *  \return   int8
 *            0 => msf1 == msf2, positive => msf1 > msf2, negative => msf1 < msf2
 *
 *  \remark
 */
/******************************************************************************/

int32 compare_msf_at(void)
{
  return (int32) T_actual - (int32) target_T;
}


/******************************************************************************/
/* Function:  check_active_msf                                                */
/*                                                                            */
/*! \brief    active_check() state function
 *  \param    void
 *  \return   uint8 OK if no action active
 *            JUMP_REQUEST if pause_on and actual_T > target_T
 *            IN_PROGRESS if action not finished
 *  \remark   Called in active_check(), when TOC reading finished and no jummp
 *            or set_speed requests are pending
 */
/******************************************************************************/

RETVAL check_active_msf(void)
{
  RETVAL check_active_msf_result;

  check_active_msf_result = OK;

  switch (servo_active_flags.field.servo_mode)
  {
  case START_MODE:
  case TOC_JUMP_MODE:
    break;

  case PAUSE_MODE:
    //mute_on();  // Delete
    switch (servo_active_flags.field.pause_state)     /* BB050810k */
    {
    case WAIT_PAUSE_CMD:
      break;
    case START_PAUSE:
      {
        lastplay_T = target_T;
        event_set_servo_endplay(SERVO_EVENT_ENDPLAY_PAUSE_CMD);
        servo_active_flags.field.pause_state = KEEP_PAUSE;   /* BB050810k */
      }

    //case KEEP_PAUSE:
    default:
      if ((T_actual >= target_T)
       || (T_actual <= (target_T + (PAUSE_TRACKS_LOWER_THS * T_ths))))
      {
        skip_trk = PAUSE_TRACKS;
        servo_seek_flags.field.seek_mode = JUMP_TARGET_PLUS_TRACKS;
        servo_seek_flags.field.seek_state = NEW_SEEK_REQUESTED;
        check_active_msf_result = JUMP_REQUEST;
      }
      break;
    }
    break;

  case PLAY_MODE:
    // FB: not to use with buffered path
    if ((0)
     && (lastrecovery_T > 0)
     && ((T_actual < lastrecovery_T) || (T_actual > (lastrecovery_T + (2 * CDT_1SEC)))))
    {
      /* PH050126a
       * Servo_mode is PLAY_MODE; if ESP is on do not recover in state PLAY_IN_PROGRESS
       * last_recovery_T is stored everytime we get into this state. When T_actual is
       * less or far away we try to reach the old position.
       * If we get there and the time is not okay, we repeat the seek, address increased
       * by 1 second
       */

      servo_recover_flags.field.active_check_recover_executed = 1;
      target_T = lastrecovery_T + CDT_1SEC;
      servo_seek_flags.field.seek_mode = SEEK_TARGET;
      servo_seek_flags.field.seek_state = NEW_SEEK_REQUESTED;
      check_active_msf_result = JUMP_REQUEST;

      /* Be sure that events are not evaluated. Now no action is needed */
    }
    else
    {
      enum {
        EMPTY                 = 0,
        IGNORE_TRACK_CHANGE   = (1 << 0),
        PAUSE_AT_TARGET       = (1 << 1),
        ACQ_TRACK_TYPE_AUDIO  = (1 << 2),
        ACQ_TRACK_TYPE_DATA   = (1 << 3),
      } local_flags = EMPTY;

      tEndPlay_type endplay_event = SERVO_EVENT_ENDPLAY_NOEVENT;
      t_bool endofseek = FALSE;

      if (!(acq_subcode_event_type & ACQ_EVENT_SUBCODE_INTERPOLATED))   /* BB050506b */
      {
        lastrecovery_T = T_actual; /* PH050126a */
      }

      switch (servo_active_flags.field.play_state)   /* BB050810k */
      {
      case WAIT_START_MSF:
        check_active_msf_result = IN_PROGRESS;
        if ((end_mode & SEEK_PLAY_UNTIL_ENDPLAY_TIME)
         && (start_mode & SEEK_START_TRAGET_MSF)
         //&& (compare_msf(target_Tmsf, endplay_Tmsf) >= 0))
         && (compare_msf_te() >= 0))
        {
          // if requested target >= endplay wrong seek request, go to pause

          local_flags |= PAUSE_AT_TARGET;
          endofseek = TRUE;
          endplay_event |= SERVO_EVENT_ENDPLAY_TARGET_TIME;
          break;
        }

        if ((data_mode & SEEK_DATA_GROOVE_REACHED) || (compare_msf_at() >= 0))
        {
          // if target is reached or is requested to finish seek when
          // groove is reached goto next state

          //oif_mute_control.mute2_on = 0;
          servo_active_flags.field.play_state = WAIT_WITH_EVENTS;   /* BB050810k */
        }
        else
        {
          // still not reached target time

          break;
        }
        /* fall through */

      case WAIT_WITH_EVENTS:
        check_active_msf_result = IN_PROGRESS;  /* BB050810g */

        /* do not go to pause until target_T is reached */
        //if ((!(compare_msf(Tmsf_actual, target_Tmsf) >= 0))
        if ((compare_msf_at() < 0)
         /*|| (local_q_events & ACQ_EVENT_SUBCODE_INTERPOLATED)*/)
        {
          break;
        }
#if 0
        else if (compare_msf_at() > 0)
        {
          acq_irq_action_event |= ACQ_SERVO_EVENT_RECOVER;  //notuses
        }
#endif
        else /* (0 == comp_result) */
        {
          endofseek = TRUE;
        }
        if (!(end_mode & SEEK_CHECK_TRACK_CHANGE_ON))
        {
          local_flags |= IGNORE_TRACK_CHANGE;
        }
        servo_active_flags.field.play_state = PLAY_IN_PROGRESS;   /* BB050810k */
        tracking_recover_dither_counter = 0;
        /* fall through */

      //case PLAY_IN_PROGRESS:
      default:
        if (current_tno_bcd != acq_last_tno)
        {
          acq_subcode_event_type |= ACQ_EVENT_SUBCODE_NEW_TRACK;
        }

        if ((end_mode & SEEK_PLAY_UNTIL_ENDPLAY_TIME)
         //&& (compare_msf(Tmsf_actual, endplay_Tmsf) >= 0))
         && (compare_msf_ae() >= 0))
        {
          endplay_event |= SERVO_EVENT_ENDPLAY_TARGET_TIME;
        }
        if ((0 == (local_flags & IGNORE_TRACK_CHANGE))
         && (end_mode & SEEK_PLAY_UNTIL_TRACK_CHANGE)
         && (acq_subcode_event_type & ACQ_EVENT_SUBCODE_NEW_TRACK))
        {
          endplay_event |= SERVO_EVENT_ENDPLAY_TRACK_CHANGED;
        }
        if (end_mode & SEEK_PLAY_UNTIL_LEADINOUT)
        {
          if (acq_subcode_event_type & ACQ_EVENT_SUBCODE_LEADOUT)
          {
            endplay_event |= SERVO_EVENT_ENDPLAY_LEADOUT;
            //Fix For Missing Pause At end of the disc
            servo_active_flags.field.pause_state = START_PAUSE;
          }
          else if (acq_subcode_event_type & ACQ_EVENT_SUBCODE_LEADIN)
          {
            endplay_event |= SERVO_EVENT_ENDPLAY_LEADIN;
          }
        }
        if ((end_mode & SEEK_PLAY_UNTIL_AUDIO_TRACK)
         && (0 != (ACQ_TRACK_TYPE_AUDIO & local_flags)))
        {
          endplay_event |= SERVO_EVENT_ENDPLAY_AUDIO_TRACK;
        }
        if ((end_mode & SEEK_PLAY_UNTIL_DATA_TRACK)
         && (0 != (ACQ_TRACK_TYPE_DATA & local_flags)))
        {
          endplay_event |= SERVO_EVENT_ENDPLAY_DATA_TRACK;
        }

        if (acq_subcode_event_type & ACQ_EVENT_SUBCODE_NEW_TRACK)   /* BB051103a */
        {
          current_tno_bcd = acq_last_tno;
        }

        previous_T = T_actual;
        lastplay_T = T_actual;
        update_subcode_events(endofseek);
        servo_recover_flags.field.active_check_recover_executed = 0;

        /* if recovery is executed mute off */
        //mute_off();
        break;
      }

      if (0 != endplay_event)
      {
        check_active_msf_result = IN_PROGRESS;   /* BB050412b */
        event_set_servo_endplay(endplay_event);
        update_subcode_events(endofseek);

        if (0 == (local_flags & PAUSE_AT_TARGET))
        {
          target_T = T_actual;  // TODO
        }

        lastplay_T = target_T;
        lastrecovery_T = target_T;
        servo_active_flags.field.servo_mode = PAUSE_MODE;
        servo_active_flags.field.pause_state = WAIT_PAUSE_CMD;

        current_pause_tno_bcd = acq_last_tno;
        //oif_mute_control.mute1_on = 1;
      }
    }
    break;

  default:
    /* do nothing */
    break;
  }

  return check_active_msf_result;
}


/******************************************************************************/
/* Function:  CIRC_Int_irq                                                    */
/*                                                                            */
/*! \brief    Handler for interrupt out of CIRC block
 *  \param    void
 *  \return   void
 *  \remark   The CIRC interrupt is active under three conditions:
 *            data rate at the input is too high, end of self test or
 *            every 32 sectors (used for BER measurements)
 */
/******************************************************************************/

#ifdef APM_PICKUP
void CIRC_Int_irq(void)
{
  if (ECC_IT.field.ssd32)   /* Every 32 CD Sectors (32 Q-Subcode frames [32 * 1/75 second]). */
  {
    servo_acq_flags.field.ecc_cntr_ready = 1;

    /* During the complete measurement the must be in play, if this was
    ** not the case, e.g. while the module switched to pause mode because
    ** the ESP was full, then the measurement is rejected. */
    if (service_flag_is_set(SVCF_ACCEPT_ECC_MEASUREMENT))
    {

      /* Report Byte Error Rate measurement. */
      service_report_ber_meas();

      /* Accumulate C2 errors during the "Get playability" analysis. */
      service_playability_analysis();

    }
    else
    {

      /* Reject measurement, prepare accept-flag for next measurement. */
      service_set_flag(SVCF_ACCEPT_ECC_MEASUREMENT);

    }
  }
}
#endif


/******************************************************************************/
/* Function:  jitter_val                                                      */
/*                                                                            */
/*! \brief    provides jitter value, read back from acquisition
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void jitter_val(void)
{  
  //uint8           j; 
  uint8           jitter_val;
  //uint16          average_jitter_val;
  
  //After Reset the ACQ_JITTER register provides is 0.
  
  if(ACQ_STATUS.field.unlocked)
  {
   //Acquisition PLL Unlocked
   jitter_val = 0x00;
  }
  else
  {
   jitter_val = ACQ_JITTER;
  }                                   

#if 0
  for(j=JITTER_SAMPLES; j>0; j--)
  {
   jitter_val_vect[j] = jitter_val_vect[j-1];
  }
  jitter_val_vect[0] = jitter_val;
  
  average_jitter_val = 0;
  
  for(j=0; j<JITTER_SAMPLES; j++)
  {
   average_jitter_val += jitter_val_vect[j];   
  }
  
                  
  average_jitter_val = (average_jitter_val / JITTER_SAMPLES) & 0xFF;
  
  //Max Jitter value is 19%
  //19% means jitter_val = 0x62.
 #endif
  
  //jitter_percentage_val = (average_jitter_val * 100)/512;
  jitter_percentage_val = (jitter_val * 100)/512;  
}


#endif // HAVE_CD_MECHA