loader.c

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

/**************************************************
 *
 * loader.c
 *
 * CVS ID:   $Id: loader.c,v 1.27 2007/10/02 14:19:38 dellorto Exp $
 * Author:   Fabio Dell'Orto [FD] - STM
 * Date:     $Date: 2007/10/02 14:19:38 $
 * Revision: $Revision: 1.27 $
 * 
 * Description:
 * 
 *   Main entry point for the Loader task.
 *
 ***************************************************
 * 
 * COPYRIGHT (C) ST Microelectronics  2005
 *            All Rights Reserved
 *
 ***************************************************
 *
 * STM CVS Log:
 *
 * $Log: loader.c,v $
 * Revision 1.27  2007/10/02 14:19:38  dellorto
 * improved conservative behavior for Shinwa CDC02
 * fixed stop insertion for Shinwa CLC01
 * fixed size detection for Tanashin
 *
 * Revision 1.26  2007/09/26 15:04:54  dellorto
 * fixed timings for Shinwa CDC02
 *
 * Revision 1.25  2007/09/07 07:07:03  dellorto
 * Bug fixing and improvements in Tanashin loader
 *
 * Revision 1.24  2007/08/14 15:27:56  dellorto
 * multiple mechanisms
 *
 * Revision 1.22  2006/12/19 17:07:29  dellorto
 * mechanical initialization according to Shinwa recommendation (30 ms Eject, in case of no cd)
 * fixed insert transition (in case of disc moved in eject direction)
 * improved error reporting to player, for recoveries
 * fixed behavior using the following configuration: conservative behavior;  insert/eject with no cd; reverse direction not allowed
 * improved illegal switching and disc size detection
 * clean-up from unused ldr_retval variable, updated function headers, code optimization
 *
 * Revision 1.21  2006/12/04 14:50:28  dellorto
 * loader improved, according to new timing specification
 *
 * Revision 1.20  2006/10/26 10:23:43  dellorto
 * improved alignements with Shinwa transition timings
 * improved protection against illegal switchings
 * improved handling of mechanisms with altered chuck switch
 *
 * Revision 1.19  2006/10/09 15:17:06  dellorto
 * added LoaderTask, moved from osal.c
 *
 * Revision 1.18  2006/09/27 19:52:04  belardi
 * Removed (global) unused variables
 *
 * Revision 1.17  2006/09/18 09:55:23  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.16  2006/09/18 09:24:22  belardi
 * Added Log CVS keyword into file header
 *
 *
 ***************************************************/

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

#include "utility.h"
#include "loader.h"
#include "monitor.h"
#include "plr_conf.h"

#include "debug.h"

#if (HAVE_CD_MECHA == 1)

/*----------------------------------------------------------------------------*/
/*------------------------    Macros -----------------------------------------*/
/*----------------------------------------------------------------------------*/

#define ldrSendEvent(x) do {                              \
  event_out[LOADER_STATUS_EVENT].event = (x);             \
  DEBUG_LOADER_STATUS_EVENT(("LOADER_EVENT:", 1, 1, x));  \
} while(0)


/*----------------------------------------------------------------------------*/
/*------------------------    local vars  ------------------------------------*/
/*----------------------------------------------------------------------------*/

t_disc_size disc_size;
uint8 previous_ldr_switch_state;

t_loader_state ldr_state;                 /*!<\brief Current loader state */

t_motor_direction  ldr_motor_dir;         /*!<\brief Current motor direction */

#define LDR_SET_CMD_EVENT(x) do {           \
  event_out[LOADER_CMD_EVENT].event = (x);  \
  event_cmd_set(LOADER_CMD_EVENT);          \
} while(0)

#define LDR_CMD_EVENT     event_in[LOADER_CMD_EVENT].event
#define LDR_SW_EVENT      event_in[LOADER_SW_EVENT].event

#define ldr_command       LDR_CMD_EVENT
#define ldr_switch_state  LDR_SW_EVENT




/*----------------------------------------------------------------------------*/
/*------------------------    Function implementations   ---------------------*/
/*----------------------------------------------------------------------------*/


/******************************************************************************/
/* Function:  set_loader_input                                                */
/*                                                                            */
/* \brief     set the loader motor input
 * \param     uint16 loader input 
 * \return    void
 * \remark
 */
/******************************************************************************/

void set_loader_input(int16 loader_input)
{
  DISABLE_INTERRUPTS();
  DSP_SSPDL = (uint8)(loader_input & 0xFF);
  DSP_SSPDH = (uint8)(loader_input >> 8);
  ENABLE_INTERRUPTS();
}


/******************************************************************************/
/* Function:  ldrSetMotor                                                     */
/*                                                                            */
/*! \brief    
 *  \param    t_motor_direction direction
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void ldrSetMotor(t_motor_direction direction)
{
  ldr_motor_dir = direction;

  if (IS_TANASHIN_MECHANISM(mechanism_model))
  {
    switch (direction)
    {
    case LOADER_DIR_INSERT:
      DRIVER_ON;
      set_loader_input(LOADER_PRO_INSERT_PARAM);
      break;

    case LOADER_DIR_EJECT:
      DRIVER_ON;
      set_loader_input(LOADER_PRO_EJECT_PARAM);
      break;

    //case LOADER_DIR_IDLE:
    default:
      set_loader_input(0x0000);
      DRIVER_OFF;
      break;
    }
  }
  else
  {
    switch (direction)
    {
    case LOADER_DIR_INSERT:
      set_gpio(PORT_A, GPIO_1, LOADER_PRO_INSERT_GPIO_1);
      set_gpio(PORT_A, GPIO_2, LOADER_PRO_INSERT_GPIO_2);
      break;

    case LOADER_DIR_EJECT:
      set_gpio(PORT_A, GPIO_1, LOADER_PRO_EJECT_GPIO_1);
      set_gpio(PORT_A, GPIO_2, LOADER_PRO_EJECT_GPIO_2);
      break;

    //case LOADER_DIR_IDLE:
    default:
      set_gpio(PORT_A, GPIO_1, 0);
      set_gpio(PORT_A, GPIO_2, 0);
      break;
    }
  }
}


/******************************************************************************/
/* Function:  StartActionTo                                                   */
/*                                                                            */
/*! \brief    
 *  \param    t_motor_direction direction
 *  \param    t_loader_state state
 *  \param    OSAL_TIME_t time
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartActionTo(t_motor_direction direction, t_loader_state state, OSAL_TIME_t time)
{
  if (LOADER_S_EJECT_8CM_SUSPICIOUS == state)
  {
    disc_size = DISC_SIZE_8CM_SUSPICIOUS;
    state = LOADER_S_EJECT_8CM_1;
  }

  if (T0ms != time)
  {
    start_timer(LOADER_TIMER, time);
  }

  ldrSetMotor(direction);
  ldr_state = state;
}


/******************************************************************************/
/* Function:  StartInsertTo                                                   */
/*                                                                            */
/*! \brief    
 *  \param    t_loader_state state
 *  \param    OSAL_TIME_t time
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartInsertTo(t_loader_state state, OSAL_TIME_t time)
{
  StartActionTo(LOADER_DIR_INSERT, state, time);
}


/******************************************************************************/
/* Function:  StartEjectTo                                                    */
/*                                                                            */
/*! \brief    
 *  \param    t_loader_state state
 *  \param    OSAL_TIME_t time
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartEjectTo(t_loader_state state, OSAL_TIME_t time)
{
  StartActionTo(LOADER_DIR_EJECT, state, time);
}


/******************************************************************************/
/* Function:  IdleMode                                                        */
/*                                                                            */
/*! \brief    
 *  \param    t_loader_status_event event
 *  \param    t_loader_state state
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void IdleMode(t_loader_status_event event, t_loader_state state)
{
  if ((READY != event)
   && (LOADER_S_NOCD_INSERTING != ldr_state)
   && (LOADER_S_NOCD_EJECTING != ldr_state)
   && ((LOADER_S_EJECT_8CM_1 != ldr_state)
    || (DISC_SIZE_8CM_SUSPICIOUS != disc_size)))
  {
    ldr_command = LC_NONE;
  }

  if (LOADER_S_NO_CD_POSITION == state)
  {
    disc_size = DISC_SIZE_UNKNOWN;
  }

  ldrSetMotor(LOADER_DIR_IDLE);
  ldrSendEvent(event);
  ldr_state = state;
}


/******************************************************************************/
/* Function:  ldrPrepareError                                                 */
/*                                                                            */
/*! \brief    Prepare loader error state
 *  \param    RETVAL ldr_error_event
 *  \return   void
 *  \remarks
 */
/******************************************************************************/

void ldrPrepareError(RETVAL ldr_error_event)
{
  IdleMode(ldr_error_event, LOADER_S_ERROR);
}




/*****************************************************************************/
/*                                                                           */
/*                              M0_SHINWA_CDC02                              */
/*                                                                           */
/*****************************************************************************/


/******************************************************************************/
/* Function:  StartInsert_Shinwa_CDC02                                        */
/*                                                                            */
/*! \brief    Start disc insertion according to current position
 *            (implementation for mechanism: M0_SHINWA_CDC02)
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartInsert_Shinwa_CDC02(void)
{
  switch (SW_VALUE(ldr_switch_state))
  {
  case SW_S_010_INSERT:
    StartInsertTo(LOADER_S_INSERT_1, T5s);
    break;

  case SW_S_110_EJECT:
    StartInsertTo(LOADER_S_INSERT_2, T5s);
    break;

  case SW_S_000_STOP:
    StartEjectTo(LOADER_S_INSERT_REPOSITIONING, T1s);
    break;

  case SW_S_100_TRANSITION:
    StartInsertTo(LOADER_S_INSERT_4, T3s5);
    break;

  case SW_S_111_8CM:
    StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    ldrSendEvent(LOADER_ERROR_8CM);
    break;
       
  case SW_S_011_NOCD:
    StartEjectTo(LOADER_S_EJECT_8CM_SUSPICIOUS, T1s);
    ldrSendEvent(LOADER_ERROR_8CM);
    break;

  //SW_S_001_ILLEGAL:
  //SW_S_101_ILLEGAL:
  default:
    ldrSendEvent(LOADER_ERROR_SW_ILLEGAL);
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
    break;
  }
}


/******************************************************************************/
/* Function:  StartEject_Shinwa_CDC02                                         */
/*                                                                            */
/*! \brief    Start disc ejection according to current position
 *            (implementation for mechanism: M0_SHINWA_CDC02)
 *  \param    void
 *  \return   void
 *  \remark
 */
/******************************************************************************/

void StartEject_Shinwa_CDC02(void)
{
  switch (SW_VALUE(ldr_switch_state))
  {
  case SW_S_000_STOP:
  case SW_S_100_TRANSITION:
    StartEjectTo(LOADER_S_EJECT_12CM_1, T2s);
    break;

  case SW_S_111_8CM:
    StartEjectTo(LOADER_S_EJECT_8CM_1, T1s);
    break;

  case SW_S_010_INSERT:
  case SW_S_110_EJECT:
    StartInsertTo(LOADER_S_EJECT_REPOSITIONING, T1s);
    break;

  case SW_S_011_NOCD:
    StartEjectTo(LOADER_S_EJECT_8CM_SUSPICIOUS, T1s);
    break;
 
  //SW_S_001_ILLEGAL:
  //SW_S_101_ILLEGAL:
  default:
    ldrSendEvent(LOADER_ERROR_SW_ILLEGAL);
    StartEjectTo(LOADER_S_EMERGENCY_EJECT, T5s);
    break;
  }
}


/******************************************************************************/
/* Function:  ldrCommandEval_Shinwa_CDC02                                     */
/*                                                                            */
/*! \brief    Start actions for a new Loader Command
 *            (implementation for mechanism: M0_SHINWA_CDC02)
 *  \param    void
 *  \return   void
 *  \remarks
 */
/******************************************************************************/

void ldrCommandEval_Shinwa_CDC02(void)
{
  t_bool illegal_switch_detected = b_FALSE;

  if ((SW_VALUE(ldr_switch_state) != SW_VALUE(previous_ldr_switch_state))
   && (LOADER_S_STOP_POSITION != ldr_state)
   && (LOADER_S_EMERGENCY_EJECT != ldr_state))
  {
    if ((SW_INVALID_VAL != SW_VALUE(previous_ldr_switch_state))
     && ((SW_S_001_ILLEGAL == SW_VALUE(ldr_switch_state))
      || (SW_S_101_ILLEGAL == SW_VALUE(ldr_switch_state))
      || ((DISC_SIZE_12CM == disc_size)
       && ((SW_S_111_8CM == SW_VALUE(ldr_switch_state))
        || ((SW_S_011_NOCD == SW_VALUE(ldr_switch_state))
         && (SW_S_010_INSERT != SW_VALUE(previous_ldr_switch_state)))))
      || (((DISC_SIZE_8CM == disc_size)
        || (DISC_SIZE_8CM_SUSPICIOUS == disc_size))
       && ((SW_S_100_TRANSITION == SW_VALUE(ldr_switch_state))
        || (SW_S_000_STOP == SW_VALUE(ldr_switch_state))))
      || ((DISC_SIZE_UNKNOWN == disc_size)
       && (((SW_S_011_NOCD == SW_VALUE(previous_ldr_switch_state))
         && (SW_S_010_INSERT != SW_VALUE(ldr_switch_state)))))))
    {
      // on illegal SW state
      illegal_switch_detected = b_TRUE;