controller.h

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

#define CTR_READ_FSM_SERVO_START  1
#define CTR_READ_FSM_WAIT_START   2
#define CTR_READ_FSM_PREPARE      3
#define CTR_READ_FSM_READ         4
#define CTR_READ_FSM_WAIT         5
#define CTR_READ_FSM_WAIT_READ_READY 6

#if (0 != HAVE_UPDATE)
// states of FSM UPDATE
#define CTR_UPDATE_FSM_STARTUP          (0)
#define CTR_UPDATE_FSM_ERASE            (1)
#define CTR_UPDATE_FSM_ERASE_WAIT       (2)
#define CTR_UPDATE_FSM_FEED_DATA        (4)
#define CTR_UPDATE_FSM_WAIT_READ_READY  (5)
#define CTR_UPDATE_FSM_WAIT_CD          (6)
#define CTR_UPDATE_FSM_READ_CD          (7)
#define CTR_UPDATE_FSM_READ_CACHE       (8)
#define CTR_UPDATE_FSM_WAIT_DMA         (9)
#if (0 != HAVE_USB)
#define CTR_UPDATE_FSM_WAIT_USB         (10)
#endif /* HAVE_USB */
#if (0 != HAVE_SDC)
#define CTR_UPDATE_FSM_WAIT_SDC         (11)
#endif /* HAVE_SDC */
#define CTR_UPDATE_FSM_WAIT_FOR_DATA    (12)
#define CTR_UPDATE_FSM_WRITE            (13)
#define CTR_UPDATE_FSM_WRITE_WAIT       (14)
#define CTR_UPDATE_FSM_NEXT             (15)
#define CTR_UPDATE_FSM_CLEAR            (16)
#define CTR_UPDATE_FSM_CLEAR_WAIT       (17)
#define CTR_UPDATE_FSM_CHECKSUM         (18)
#define CTR_UPDATE_FSM_CHECKSUM_WAIT    (19)
#define CTR_UPDATE_FSM_EJECT            (20)
#define CTR_UPDATE_FSM_ERROR            (21)
#if (0 != HAVE_HOST_UPDATE)
#define CTR_UPDATE_WAIT_HOSTIF_CMD      (22)
#endif
#endif /* HAVE_UPDATE */

typedef enum
{
  CONTROLLER_STATE_RESET,
  CONTROLLER_STATE_IDLE,
  CONTROLLER_STATE_FS_DETECT,
  CONTROLLER_STATE_FS_SCAN,
  CONTROLLER_STATE_MEDIA_READY,
  CONTROLLER_STATE_INIT_PLAY,
  CONTROLLER_STATE_PLAY,
  CONTROLLER_STATE_FILLING_FB, //[OK]
} t_controller_state;

typedef struct TagControllerState
{
  t_controller_state state;
  uint16 status;
} t_ControllerState;



typedef struct
{
  t_controller_state state;
  uint8 fs_detected;
  uint8 fs_scanned;
  uint8 fastseek_on; //[OK]
  struct
  {
    RETVAL fsm_result;
    RETVAL error_reason;
    RETVAL controller_transition;
  } status;
} t_controller_status_event;


// TODO use it also in controller
#define START_OFFSET_BOS          0
#define START_OFFSET_CURRENT_POS  1
#define START_OFFSET_EOS          2


typedef enum
{
  CONTROLLER_CMD_NO,
  CONTROLLER_CMD_INIT,
  CONTROLLER_CMD_INIT_FOR_NEW_DISC,
  CONTROLLER_CMD_START,        //  FD will be removed
  CONTROLLER_CMD_SET_SPEED,    //  FD will be removed
  CONTROLLER_CMD_READ_TOC,
  CONTROLLER_CMD_MOUNT_FS,
  CONTROLLER_CMD_STOP,
  CONTROLLER_CMD_PLAY_AT,
  CONTROLLER_CMD_PAUSE_AT,
  CONTROLLER_CMD_SEARCH_AT,
  CONTROLLER_CMD_READ,
#if (0 != HAVE_UPDATE)
  CONTROLLER_CMD_UPDATE,
#endif
#if (0 != HAVE_HOST_UPDATE)
  CONTROLLER_CMD_ABORT_HOST_UPDATE,
  CONTROLLER_CMD_HOST_UPDATE,
#endif /* HAVE_UPDATE */
	CONTROLLER_CMD_DEV_INIT,	//[LL]
	CONTROLLER_CMD_DEV_CLOSE	//[LL]
} t_controlled_command;

typedef struct
{
  UInt do_search_forward  : 1;
  UInt unused  : 31;
  t_offset play_offset;
  t_offset jump_offset;
} t_SearchParams;

typedef struct
{
  DUID did;
  t_controlled_command command;

  UInt force_execution    : 1;
  t_position start;               /* PLAY_AT, PAUSE_AT, SEARCH_AT, READ */
  t_offset stop_offset;           /* PLAY_AT, SEARCH_AT, READ */
  uint8 end_mode;                 /* PLAY_AT, PAUSE_AT, SEARCH_AT */

  union
  {
    struct
    {
      uint8 speed;
    } set_speed_params;

    struct
    {
      UInt playback         : 1;   // stops playback
      UInt mount            : 1;
      UInt device           : 1;   // stops selected device independently of playback - according to DID in cmd
    } stop_params;

    struct
    {
      void *buffer;
    } read_params;

    t_SearchParams search_at_params;
  } extra;
} t_controller_cmd_event;


/*---------------------------------------------------------------------------*/
/*!\brief Controller Task inevent/outevent def                                  */
/*---------------------------------------------------------------------------*/

typedef struct
{
  t_lba  start_lba;
  t_lba  end_lba;
  uint16 offset;
  uint32 count;
  uint16 sector_size;
} ESP_BLOCK_INFO;


typedef enum
{
  CHILD_CMD_INIT,		/* initialize the peripheral */
  CHILD_CMD_STOP,		/* stop data transfer */
  CHILD_CMD_START,				//redundant
  CHILD_CMD_SET_SPEED,			//redundant
  CHILD_CMD_INIT_FOR_NEW_DISC,	//redundant
  CHILD_CMD_UPDATE_PARAMS,		//redundant
  CHILD_CMD_PAUSE,				//redundant
  CHILD_CMD_XFER_DATA,	/* start data transfer */
#if (1 == HAVE_WMDRM)
  CHILD_CMD_MTP,
#endif
  CHILD_CMD_BACKGROUND,	/* ? */
  CHILD_CMD_CLOSE,		/* close the peripheral */
} t_child_command;

struct t_child_stop_event
{
  UInt force_execution : 1;
  UInt unused : 31;
};

typedef struct
{
  t_lba sector_start;
  t_lba sector_stop;
  uint16 offset;
  uint16 sector_size;
  uint8 *dest;
  uint32 count;
  UInt force_execution : 1;
  UInt Play_Mode : 1;//DR060912 Play Mode Flag declaration
  UInt dont_ignore_first_track_change : 1;
  UInt FB_mode : 1;
  UInt update_process : 1;
  UInt buffering_mode : 1;
  UInt data_type : 4;
  uint8 cur_TNO;
  uint8 end_mode;
  uint16 flags;
  t_XNodeType type; /* x-file type (MP3, WMA, CDDA) */
}t_child_xfer_event;

#if (1 == HAVE_WMDRM)
/* MTP : Media Transfer Protocol for WMDRM */
typedef struct
{
  uint16 mtp_cmdcode;
  uint32 *ope_param;
  uint8  param_number;
  uint8  *pbMessageToSend;     // sending data
  uint32 cbMessageToSend;      // sending data size
  uint8  **pbMessageReceived;  // receive data
  uint32 *cbMessageReceived;   // received data size
  uint16 *mtp_ResCode;		   // mtp response code
}t_child_mtp_event;
#endif

typedef struct //child_cmd_event
{
  void* hDevice;
  t_duid did;
  t_child_command command;
  union
  {
    struct t_child_stop_event stop_params;
    t_child_xfer_event xfer_params;
#if (1 == HAVE_WMDRM)
    t_child_mtp_event mtp_params;
#endif
  } command_params;
} t_child_cmd_event;

void InitControllerTask(void);
void controller_process_events(void);
RETVAL controller_cmd(t_controller_cmd_event *cmd_event);
void CTR_InitDevLibrary(void);
void CTR_DetectFS(void);
ElementFlagType CTR_FillFrameBuffer(void);
t_controller_state CTR_CmdPlayNext(uint8 forced);
t_controller_state CTR_CmdFastSeek(uint8 direction);

void capture_update_status(uint32 inevent);
uint16 GetCurrentBitRate(void);
void GetCurrentPosition(t_position *position);

t_position get_current_position(void);
t_position get_lastplay_position(void);
t_position get_lastread_position(void);

#if (0 != HAVE_HOST_UPDATE)
extern t_bool use_host_update_fsm;
#endif

extern t_child_cmd_event FS_XFER_command_event;
extern uint32 GetCurrentStartOffset(void);

#define FRAMES_2_MILISEC(fr)  ((1000*(fr)) / 75)
#define FRAMES_2_BYTES(fr)    ((fr)*2352)
#define BYTES_2_FRAMES(byte)  ((byte) / 2352) /* round */
#define MILISEC_2_FRAMES(ms)  (((ms)*75) / 1000)
#define BYTES_2_MILISEC(byte) (882*(byte)/5)           /* 75*2352/1000 */
#define MILISEC_2_BYTES(ms)   ((5*(ms)) / 882)   /* round */
#define SUBCODE_2_BYTES(subcode) FRAMES_2_BYTES( \
                                  ((bcd_2_hex((subcode).q_subcode.q_min) * 60) \
                                  + bcd_2_hex((subcode).q_subcode.q_sec)) * 75 \
                                  + bcd_2_hex((subcode).q_subcode.q_frame))

#define ASUBCODE_2_BYTES(subcode) FRAMES_2_BYTES( \
                                  ((bcd_2_hex((subcode).q_subcode.q_amin) * 60) \
                                  + bcd_2_hex((subcode).q_subcode.q_asec)) * 75 \
                                  + bcd_2_hex((subcode).q_subcode.q_aframe))

#define FRAMES_2_OFFSET(fr)   (FRAMES_2_BYTES(fr)>>2)
#define COMPRESSED_BYTES_2_OFFSET(cb,byterate) ((((cb) * 3) / (byterate))*2352*25)
#define SUBCODE_2_OFFSET(subcode) FRAMES_2_OFFSET( \
                                  ((bcd_2_hex((subcode).q_subcode.q_min) * 60) \
                                  + bcd_2_hex((subcode).q_subcode.q_sec)) * 75 \
                                  + bcd_2_hex((subcode).q_subcode.q_frame))

#define FORCED_PAUSE_AT_CURRENT_POS ((CONTROLLER_CMD.command == CONTROLLER_CMD_PAUSE_AT) \
                                  && (CONTROLLER_CMD.start.offset == START_OFFSET_CURRENT_POS) \
                                  && (CONTROLLER_CMD.force_execution))

#define PLAY_AT_CURRENT_POS ((CONTROLLER_CMD.command == CONTROLLER_CMD_PLAY_AT) \
                       && (CONTROLLER_CMD.start.offset == START_OFFSET_CURRENT_POS))

#define SEARCH_AT_CURRENT_POS ((CONTROLLER_CMD.command == CONTROLLER_CMD_SEARCH_AT) \
                       && (CONTROLLER_CMD.start.offset == START_OFFSET_CURRENT_POS))

#define CTR_CURRENTLY_PLAYING ((controller_data_fsm.state == FSM_RUN) || (controller_play_fsm.state == FSM_RUN))

#define CTR_SEARCH_MODE (((controller_play_fsm.state == FSM_RUN) && (controller_play_fsm_params.search_mode)) \
                      || ((controller_data_fsm.state == FSM_RUN) && (controller_CD_data_fsm_params.search_mode)))

#define IS_SAME_SEARCH_MODE ((((controller_play_fsm.state == FSM_RUN) && (controller_play_fsm_params.SearchParams.do_search_forward == CONTROLLER_CMD.extra.search_at_params.do_search_forward))        \
                           || ((controller_data_fsm.state == FSM_RUN) && (controller_CD_data_fsm_params.SearchParams.do_search_forward == CONTROLLER_CMD.extra.search_at_params.do_search_forward)))    \
                           &&(((controller_play_fsm.state == FSM_RUN) && (controller_play_fsm_params.SearchParams.play_offset == CONTROLLER_CMD.extra.search_at_params.play_offset))                    \
                           || ((controller_data_fsm.state == FSM_RUN) && (controller_CD_data_fsm_params.SearchParams.play_offset == CONTROLLER_CMD.extra.search_at_params.play_offset)))    \
                           &&(((controller_play_fsm.state == FSM_RUN) && (controller_play_fsm_params.SearchParams.jump_offset == CONTROLLER_CMD.extra.search_at_params.jump_offset))                    \
                           || ((controller_data_fsm.state == FSM_RUN) && (controller_CD_data_fsm_params.SearchParams.jump_offset == CONTROLLER_CMD.extra.search_at_params.jump_offset))))    
                           
#define PAUSE_RELEASING_CMD (CTR_CURRENTLY_PLAYING \
                          && ((SEARCH_AT_CURRENT_POS && CTR_SEARCH_MODE) \
                           || (PLAY_AT_CURRENT_POS && (!CTR_SEARCH_MODE))))
// ************************************************** //

// FSM states:
#define FSM_IDLE  0
#define FSM_RUN   1
#define FSM_DONE  2
#define FSM_ERROR 3

typedef struct
{
  uint8 state;
  uint8 transition;
  uint8 parent_notify;
  GRESULT error_reason;
  // void params;
  uint8 dbgstate;
  uint8 dbgtransition;
  uint8 *name;
} t_fsm;


void FSM_init(t_fsm *fsm, uint8 *name);
void FSM_deactivate(t_fsm *fsm, uint32 out_event);
void FSM_activate(t_fsm *fsm, uint8 start_transition, uint8 parent_notify);
#endif