accordoptimer.c

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

/******************************************************************************/
/* Function:  initial_messaging_timeout                                       */
/*                                                                            */
/*! \brief
 *  \param    signals initial state of USB/SDC
 *  \return   void
 *  \remark
 */
/******************************************************************************/
static t_timeout_flags initial_messaging_timeout(void)
{
#if (0 != HAVE_USB)
  if (!((player_mount_params.DevicesWaitingForMount & DEV_USB_ID) || (player_params.DevicesReady & DEV_USB_ID) || (player_params.DevicesReady & DEV_IPOD_ID)))
    report_msg_insert_mode(USB_DISCONNECT,DUMMY_VALUE,DUMMY_VALUE);
#endif /*HAVE_USB*/
#if (0 != HAVE_SDC)
  if (!((player_mount_params.DevicesWaitingForMount & DEV_SDC_ID) || (player_params.DevicesReady & DEV_SDC_ID)))
    report_msg_insert_mode(SDC_DISCONNECT, DUMMY_VALUE, DUMMY_VALUE);
#endif /*HAVE_SDC*/
  return TIMFLG_NULL;
}

//#if defined(APM_PICKUP) || #if (0 != HAVE_TEMP_SENSOR)
#define  temperature_timeout  dummy_timeout  /* handled by monitor */
//#endif

#if (0 != HAVE_WMDRM)
static t_timeout_flags filesys_timeout(void)
{
  return TIMFLG_NULL;
}
#endif

#if (OS20_PROFILING == 1)
static t_timeout_flags profiling_timeout(void)
{
  extern uint8 print_profiling;
  Stop_profiling();

#if (0 != HAVE_PRINTF)
  svc_msg_set_pending(SVC_MSG_PROFILING);
#endif

  OSAL_wake_thread(OSAL_THREAD_HostIfTask);
  return TIMFLG_NULL;
}
#endif

static const t_timeout_callback timeout_event[MAX_TIMERS] =
{
#if (HAVE_CD_MECHA == 1)
  servo_timeout,            //  SERVO_SAFETY_TIMER,
  servo_timeout,            //  SERVO_FUNCTION_TIMER,
  servo_timeout,            //  SERVO_ACQ_INT_TIMER,
  servo_timeout,            //  SERVO_FOCUS_FOUND_TIMER,
  tracking_timeout,         //  SERVO_CHECK_TRACKING_TIMER,
  hf_timeout,               //  SERVO_CHECK_HF_TIMER,
  ttm_timeout,              //  SERVO_TTM_TIMER,
#endif
  controller_timeout,       //  TOC_TIMER,
#if (HAVE_CD_MECHA == 1)
  loader_timeout,           //  LOADER_TIMER,
#endif
  monitor_timeout,          //  MONITOR_TIMESLICE,
  player_timeout,           //  AUTOLOAD_TIMER,
#if (HAVE_CD_MECHA == 1)
  servo_timeout,            //  MUTE_TIMER,
#endif
#ifdef APM_PICKUP
  loader_sw_timeout,        //  LOADER_SW_TIMER,
  loader_sw_timeout,        //  LOADER_SW_DB_TIMER,
  cav_int_timeout,          //  SERVO_CAV_INT_TIMER,
  temperature_timeout,      //  TEMPERATURE_TIMER,
  hostif_timeout,           //  I2C_TIMER,
  hostif_timeout,           //  CRQ_TIMER,
#else
 #if (HAVE_CD_MECHA == 1)
  hw_eject_sw_timeout,      //  HW_EJECT_TIMER,
  loader_sw_timeout,        //  LOADER_SW1_DB_TIMER,
  loader_sw_timeout,        //  LOADER_SW2_DB_TIMER,
  loader_sw_timeout,        //  LOADER_SW4_DB_TIMER,
  sledge_timeout,           //  SERVO_SLEDGE_TIMER,
  sledge_timeout,           //  SERVO_TRACK_COUNT_TIMER,
 #endif
#if (HAVE_TEMP_SENSOR==1)
  temperature_timeout,      //  TEMPERATURE_TIMER,
  temperature_timeout,      //  TEMPERATURE_SPONT_SEND_TIMER (for spontaneous msg)
#endif  
  hostif_ll_stop_timeout,   //  HOSTIF_LL_STOP_TIMER,
  hostif_ll_crq_timeout,    //  HOSTIF_LL_CRQ_TIMER,
#endif
#if (0 != HAVE_USB)
  usb_timeout,              //  USB_TIMER,
  usb_enum_timeout,			//	USB_ENUM_TIMER
  usb_check_medium_timeout,	//	USB_CHECK_MEDIUM_TIMER
#endif
#if (0 != HAVE_SDC)
  sdc_timeout,              //  SDC_TIMER,
#endif /* HAVE_SDC */
#if((0 != HAVE_SDC) || (0 != HAVE_USB))   //JS for initial USB/SDC messaging
  initial_messaging_timeout,
#endif

#if (0 != HAVE_WMDRM)
  filesys_timeout,          //  FILESYS_TIMER for WMDRM filesystem handling
#endif

#if (OS20_PROFILING == 1)
  profiling_timeout,
#endif

};


static void reset_timeouts(void)
{
  uint8 i;
  for (i = 0; i < (uint8) MAX_TIMERS; i++)
  {
    timeout[i] = T0ms;
  }
}

static void reset_timer(void)
{
  absolute_time = 0;
}

/******************************************************************************/
/* Function:  OSAL_timer_init                                          */
/*                                                                            */
/*! \brief    Timer1 initialization function
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/
void OSAL_timer_init(void)
{
  TIM1_CR1.field.en = 0;
  TIM1_CNTR = 0x0000;      // Reset to 0xFFFC
  TIM1_SR = 0x0000;        // Reset Flags
  TIM1_CR2.field.cc = 3;   // Fcpu/cc+1
  TIM1_CR2.field.ocbie = 0;
  TIM1_CR2.field.toie = 0;
  TIM1_CR2.field.ocaie = 1;
  TIM1_OCAR = TIMER1_BASE;

  reset_timeouts();
  reset_timer();

  OSAL_isr_install(OSAL_ISR_TIMER1, 0x0f, tim1_isr_hlr_irq);
  TIM1_CR1.field.en = 1;
}

/******************************************************************************/
/* Function:  start_timeout                                          */
/*                                                                            */
/*! \brief    Start software timeout
 *  \param
 *  \return   void
 *  \remark
 */
/******************************************************************************/
void OSAL_start_timeout(OSAL_TIMEOUT_ID_t timeout_id, OSAL_TIME_t timeout_value)
{
  timeout[timeout_id] = timeout_value;
}

/******************************************************************************/
/* Function:  stop_timeout                                          */
/*                                                                            */
/*! \brief    Stop software timeout
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/
void OSAL_stop_timeout(OSAL_TIMEOUT_ID_t timeout_id)
{
  timeout[timeout_id] = 0;
}

/******************************************************************************/
/* Function:  timeout_in_progress                                          */
/*                                                                            */
/*! \brief    Checks if a timeout is running
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/
uint8 OSAL_timeout_in_progress(OSAL_TIMEOUT_ID_t timeout_id)
{
  return (timeout[timeout_id] != 0);
}

/******************************************************************************/
/* Function:  OSAL_time_get                                                   */
/*                                                                            */
/*! \brief
 *  \param    void
 *  \return   OSAL_TIME_t
 *  \remark
 */
/******************************************************************************/
OSAL_TIME_t OSAL_get_timeout(OSAL_TIMEOUT_ID_t timeout_id)
{
  return timeout[timeout_id];
}

/******************************************************************************/
/* Function:  OSAL_time_get                                                   */
/*                                                                            */
/*! \brief
 *  \param    void
 *  \return   OSAL_TIME_t
 *  \remark
 */
/******************************************************************************/
OSAL_TIME_t OSAL_time_get(void)
{
  return absolute_time;
}

/******************************************************************************/
/* Function:  OSAL_elapsed_time                                               */
/*                                                                            */
/*! \brief    get the elapsed time of the stopwatch
 *  \param    OSAL_TIME_t stopwatch_start time
 *  \return   OSAL_TIME_t
 *  \remark
 */
/******************************************************************************/
OSAL_TIME_t OSAL_elapsed_time(OSAL_TIME_t stopwatch_start)
{
  OSAL_TIME_t now;
  now = OSAL_time_get();
  if (now >= stopwatch_start)
  {
    return (now - stopwatch_start);
  }
  return (stopwatch_start - now);
}


/******************************************************************************/
/* Function:  tim1_isr_hlr_irq                                                */
/*                                                                            */
/*! \brief    Timer1 interrupt handling routine
 *  \param    void
 *  \return   void
 *  \remark   implements the software timeouts
 */
/******************************************************************************/
void tim1_isr_hlr_irq(void)
{
  uint8 i;
  t_timeout_flags timeout_flags = TIMFLG_NULL;

  TIM1_OCAR = TIMER1_BASE;
  TIM1_CR2.field.ocaie = 1;
  TIM1_SR = 0xB000; //Reset Interrupt
  TIM1_CNTR = 0x0000; // Reset to 0xFFFC
  TIM1_CR1.field.en = 1;

  absolute_time++;

  for (i = 0; i < (uint8) MAX_TIMERS; i++)
  {
    if (0 != timeout[i])
    {
      if (--timeout[i] == 0)
      {
        timeout_flags |= timeout_event[i]();
      }
    }
  }

  if (timeout_flags & TIMFLG_RUN_MONITOR)
  {
    Monitor();
  }

#if (HAVE_CD_MECHA == 1)
  if (timeout_flags & TIMFLG_RUN_LDRSW)
  {
    loader_check_switch_isr();
  }
  if (timeout_flags & TIMFLG_RUN_CHECK_TRACKING_FSM)
  {
    check_tracking_fsm_call(CHECK_TRACKING_CALLER_TIMEOUT);
  }
  if (timeout_flags & TIMFLG_RUN_CHECK_HF_FSM)
  {
    check_hf_fsm_call(CHECK_HF_CALLER_TIMEOUT);
  }
  if (timeout_flags & TIMFLG_RUN_SLEDGE_FSM)
  {
    sledge_fsm_call(SLEDGE_CALLER_TIMEOUT);
  }
  if (timeout_flags & TIMFLG_RUN_TTM_FSM)
  {
    ttm_fsm_call(TTM_CALLER_TIMEOUT);
  }
#ifndef APM_PICKUP
  if (timeout_flags & TIMFLG_RUN_HWEJSW)
  {
    check_hw_eject_switch_isr();
  }
#endif

  jitter_val();
#endif // HAVE_CD_MECHA
}