controller.c

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

  }
  else
  {
    return current_song_info.devid;
  }
}

// ****************************** CD data request management ********************************* //

GRESULT ESP_WriteRequest(t_child_xfer_event *xfer_event)
{
  t_cap_cmd_event CAP_XFER_event; // size 16 bytes

  if (next_write_force_execution_flag)
  { //following cmd must be forced
    next_write_force_execution_flag = 0;
    xfer_event->force_execution = 1;
  }

  if (Read_Request_Pending)
  {
    //dprintf("Wait read ready\r\n");
#ifdef WAIT_4_READ_READY
    return E_FAIL;
#endif    
  }

  if (xfer_event->count == 0)
    return S_OK;

  COPY_CAP_CMD(CAP_XFER_event, (*xfer_event));

  //clear all responses for cmd in event_in: ready and PRE EOS
  //all responses for cmd in event_pending are cleared at the end of CTR task
  event_in_clear(CAPTURE_STATUS_EVENT);
  event_in_clear(CAPTURE_PRE_ENDPLAY_EVENT);
  
  cap_cmd(&CAP_XFER_event);

  return S_OK;
}


GRESULT ESP_ReadRequest(t_child_xfer_event *xfer_event)
{
  // request will never be split into 2 extents (given by XAR_PrepareReadFile)

  t_cap_read_event ctr_cap_read_event; // 12 bytes

  //we are going to send new read cmd, so clear old response
  event_in_clear(CAPTURE_READ_EVENT);
  event_in_clear(CAPTURE_SUBCODE_EVENT);

      ctr_cap_read_event.dest = xfer_event->dest;
      ctr_cap_read_event.count = xfer_event->count;
      ctr_cap_read_event.offset = xfer_event->offset;
      ctr_cap_read_event.Sector_Read = xfer_event->sector_start;
      ctr_cap_read_event.Header_Trailer = CAP_DATA_REQUEST;
#ifdef CTR_CAP_DEBUG
    dprintf("New Capture read: (%u,%u) off = %u count = %u, IsReadReady = %u, Sector_Read = %u, Header_Trailer = %u\r\n", xfer_event->sector_start,xfer_event->sector_stop,xfer_event->offset,xfer_event->count,IS_CAPTURE_READ_EVENT,ctr_cap_read_event.Sector_Read,ctr_cap_read_event.Header_Trailer);
#endif    

  cap_read_cmd(&ctr_cap_read_event);

  Read_Request_Pending = 1;

  return S_OK;
}

GRESULT Update_Read_Request(t_child_xfer_event *xfer_event, uint32 read_count)
{
    if(xfer_event->count == read_count)
      return S_OK;
    
    //CAP didn't provide all data, which was requested in read request
    //update read request
    xfer_event->offset += read_count;
    xfer_event->sector_start += xfer_event->offset / xfer_event->sector_size;
    xfer_event->offset = xfer_event->offset % xfer_event->sector_size;
    xfer_event->count -= read_count;
    xfer_event->dest += read_count;
    //ask for rest of data
    return S_TRUE;
}

#if 0 // not used
uint32 Read_count(t_child_xfer_event *xfer_event)
{
    if(xfer_event->sector_start == xfer_event->sector_stop)
      return xfer_event->count;
    else
      return xfer_event->sector_size - xfer_event->offset;
}
#endif


// ******************************* ctr_wait_cap_transition *********************************** //

uint16 ctr_wait_cap_transition(void)
{
  print_fsm(&controller_wait_capture_fsm);
  if (ctr_stop_flag & DEV_CD_ID)
  { //CD stop required
    if (IS_CAPTURE_EVENT)
    { //Capture task stopped
      controller_wait_capture_fsm.state = FSM_ERROR;
      controller_wait_capture_fsm.error_reason = STOP_ERROR_REASON;
      CLEAR_ACTIVE_DEV(DEV_CD_ID);
      return CTR_TRANSITION_READ_TOC;
    }
    return 0;
  }
  else if (IS_CAPTURE_EVENT)
  {
    if (IS_CAPTURE_EVENT_READY)
    {
      controller_wait_capture_fsm.state = FSM_DONE;
      if (controller_wait_capture_fsm.parent_notify)
      { // inform player
        CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
        event_set_controller(READY | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_PAUSE_AT));
      }
    }
    else if (IS_CAPTURE_EVENT_ERROR)
    {
      controller_wait_capture_fsm.state = FSM_ERROR;
      if (controller_wait_capture_fsm.parent_notify)
      { // inform player
        controller_wait_capture_fsm.error_reason = CAPTURE_STATUS;
        CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
        event_set_controller((CAPTURE_STATUS & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_PAUSE_AT));
      }
    }
    event_in_clear(CAPTURE_STATUS_EVENT);
  }
  return 0;
}

// ******************************* ctr_init_new_disc_transition *********************************** //

uint16 ctr_init_new_disc_transition(void)
{
  t_cap_cmd_event cap_init_event;
  RETVAL child_ret;

  ctr_active_transitions |= DEV_CD_ID;

  if (ctr_stop_flag & DEV_CD_ID)
  { //CD stop required
    if (IS_CAPTURE_EVENT)
    { //Capture task stopped
      controller_init_new_disc_fsm.state = FSM_ERROR;
      controller_init_new_disc_fsm.error_reason = STOP_ERROR_REASON;
      CLEAR_ACTIVE_DEV(DEV_CD_ID);
      return CTR_TRANSITION_INIT_DISC;
    }
    return 0;
  }

  while (1)
  {
    print_fsm(&controller_init_new_disc_fsm);
    switch (controller_init_new_disc_fsm.transition)
    {
    case CTR_INIT_DISC_FSM_WAIT_READ_READY:
      if (Read_Request_Pending)
      { //there is some read request unfinished
        //dprintf("Wait read ready\r\n");
#ifdef WAIT_4_READ_READY
        return 0;
#endif        
      }
      //no read request unfinished, pass through

    case CTR_INIT_DISC_FSM_IDLE:
      XAR_DisableTOCVolume();
      SYS_ClearDeviceAttribute(CD_DEVICE_ID, DEV_ATTR_READY);
      if (current_song_info.devid == DEV_CD_ID)
      {
        current_song_info.devid = DEV_NO_DEVICE;
        current_song_info.xid = 0;
      }
      if (capturing_song_info->devid == DEV_CD_ID)
      {
        capturing_song_info->devid = DEV_NO_DEVICE;
        capturing_song_info->xid = 0;
      }

      // stop servo
      cap_init_event.did = DEV_CD_ID;
      cap_init_event.command = CAP_CMD_STOP;
      //clear all responses for cmd in event_in: ready and PRE EOS
      //all responses for cmd in event_pending are cleared at the end of CTR task
      event_in_clear(CAPTURE_STATUS_EVENT);
      event_in_clear(CAPTURE_PRE_ENDPLAY_EVENT);
      child_ret = cap_cmd(&cap_init_event);
      if (child_ret == READY)
      {
        controller_init_new_disc_fsm.transition = CTR_INIT_DISC_FSM_WAIT_READ_READY_2;
        break;
      }

      controller_init_new_disc_fsm.transition = CTR_INIT_DISC_FSM_WAIT_STOP;
      return 0; // wait for signal from capture

    case CTR_INIT_DISC_FSM_WAIT_STOP:
      if (IS_CAPTURE_EVENT)
      { // stopped or error
        if (IS_CAPTURE_EVENT_READY)
        {
          controller_init_new_disc_fsm.transition = CTR_INIT_DISC_FSM_WAIT_READ_READY_2;
          event_in_clear(CAPTURE_STATUS_EVENT);
          break;
        }
        else if (IS_CAPTURE_EVENT_ERROR)
        {
          controller_init_new_disc_fsm.state = FSM_ERROR;
          controller_init_new_disc_fsm.error_reason = CAPTURE_STATUS;
          CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
          event_set_controller((CAPTURE_STATUS & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_INIT_FOR_NEW_DISC));
          event_in_clear(CAPTURE_STATUS_EVENT);
          return 0; //CTR_TRANSITION_INIT_DISC; // no other fsm waits for this fsm
        }
      }
      return 0;

    case CTR_INIT_DISC_FSM_WAIT_READ_READY_2:
      if (Read_Request_Pending)
      { //there is some read request unfinished
        //dprintf("Wait read ready\r\n");
#ifdef WAIT_4_READ_READY
        return 0;
#endif        
      }
      //no read request unfinished, pass through

    case CTR_INIT_DISC_FSM_INIT:
      controller_init_new_disc_fsm.transition = CTR_INIT_DISC_FSM_WAIT_INIT;
      cap_init_event.did = DEV_CD_ID;
      cap_init_event.command = CAP_CMD_INIT_FOR_NEW_MEDIA;
      //clear all responses for cmd in event_in: ready and PRE EOS
      //all responses for cmd in event_pending are cleared at the end of CTR task
      event_in_clear(CAPTURE_STATUS_EVENT);
      event_in_clear(CAPTURE_PRE_ENDPLAY_EVENT);      
      child_ret = cap_cmd(&cap_init_event);
      if (child_ret == READY)
      {
        controller_init_new_disc_fsm.state = FSM_DONE;
        if (controller_init_new_disc_fsm.parent_notify)
        { // inform player
          CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
          event_set_controller(READY | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_INIT_FOR_NEW_DISC));
        }
        return 0;
      }

      break;
    case CTR_INIT_DISC_FSM_WAIT_INIT:
      if (IS_CAPTURE_EVENT)
      { // init for new disc finished
        if (IS_CAPTURE_EVENT_READY)
        {
          controller_init_new_disc_fsm.state = FSM_DONE;
          if (controller_init_new_disc_fsm.parent_notify)
          { // inform player
            CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
            event_set_controller(READY | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_INIT_FOR_NEW_DISC));
          }
        }
        else if (IS_CAPTURE_EVENT_ERROR)
        {
          controller_init_new_disc_fsm.state = FSM_ERROR;
          controller_init_new_disc_fsm.error_reason = CAPTURE_STATUS;
          if (controller_init_new_disc_fsm.parent_notify)
          { // inform player
            CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
            event_set_controller((CAPTURE_STATUS & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_INIT_FOR_NEW_DISC));
          }
        }
        event_in_clear(CAPTURE_STATUS_EVENT);
      }
      return 0;
    }
  }
}

// ******************************* ctr_read_toc_transition *********************************** //

uint16 ctr_read_toc_transition(void)
{
  RETVAL cap_result;
  GRESULT vl;

  ctr_active_transitions |= DEV_CD_ID;

  if (ctr_stop_flag & DEV_CD_ID)
  { //CD stop required
    if (IS_CAPTURE_EVENT)
    { //Capture task stopped
      controller_read_toc_fsm.state = FSM_ERROR;
      controller_read_toc_fsm.error_reason = STOP_ERROR_REASON;
      CLEAR_ACTIVE_DEV(DEV_CD_ID);
      return CTR_TRANSITION_READ_TOC;
    }
    return 0;
  }

  while (1)
  {
    print_fsm(&controller_read_toc_fsm);
    switch (controller_read_toc_fsm.transition)
    {
    case CTR_TOC_FSM_WAIT_READ_READY:
      if (Read_Request_Pending)
      { //there is some read request unfinished
        //dprintf("Wait read ready\r\n");
#ifdef WAIT_4_READ_READY
        return 0;
#endif        
      }
      //no read request unfinished, pass through

    case CTR_TOC_FSM_IDLE:
      // TBD
      // Assumed that at this point speed = CLV 1X (from INIT_NEW_DISC)
      // In future we might be running on SCP_CLV
      // Should we set speed ???

      // start servo
      cap_cmd_event.did = DEV_CD_ID;
      cap_cmd_event.command = CAP_CMD_START;
      //clear all responses for cmd in event_in: ready and PRE EOS
      //all responses for cmd in event_pending are cleared at the end of CTR task
      event_in_clear(CAPTURE_STATUS_EVENT);
      event_in_clear(CAPTURE_PRE_ENDPLAY_EVENT);      
      cap_result = cap_cmd(&cap_cmd_event);
      if (cap_result == READY)
      {
        controller_read_toc_fsm.transition = CTR_TOC_FSM_READ_TOC;
        break;
      }

      controller_read_toc_fsm.transition = CTR_TOC_FSM_WAIT_START;
      return 0; // wait for signal from capture

    case CTR_TOC_FSM_WAIT_START:
      if (IS_CAPTURE_EVENT)
      { // started or error
        if (IS_CAPTURE_EVENT_READY)
        {
          controller_read_toc_fsm.transition = CTR_TOC_FSM_READ_TOC;
          event_in_clear(CAPTURE_STATUS_EVENT);
          break;
        }
        else if (IS_CAPTURE_EVENT_ERROR)
        { // ERROR - signal upwards
          controller_read_toc_fsm.error_reason = CAPTURE_STATUS;
          controller_read_toc_fsm.state = FSM_ERROR;
          if (controller_read_toc_fsm.parent_notify)
          {
            CLEAR_ACTIVE_DEV(DEV_CD_ID);         //command finished
            event_set_controller((CAPTURE_STATUS & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_READ_TOC));
            event_in_clear(CAPTURE_STATUS_EVENT);
            return 0;
          }
          event_in_clear(CAPTURE_STATUS_EVENT);
          return CTR_TRANSITION_READ_TOC; // mount can wait for toc
        }
      }
      return 0;

    case CTR_TOC_FSM_READ_TOC:
      controller_read_toc_fsm.transition = CTR_TOC_FSM_READING;
      if (toc_flags.field.toc_fsm_started == 0)
      {
        toc_flags.field.toc_fsm_started = 1;
        if (0 == (CDinfo & ALL_TOC_READ))
        {
#if (1==HAVE_CDTEXT)
          CDText_init();
          controller_enable_hw_text();
#endif
          toc_state = READ_FIRST_TOC;  //STTODO add proper init function
        }
      }
      //return 0;

    case CTR_TOC_FSM_READING:
      if (1) //(IS_CAPTURE_EVENT) || (IS_CAPTURE_SUBCODE_EVENT))
        // toc reading in progress or error
      {
        RETVAL toc_result;

        toc_result = toc_fsm();
        // Begin
        // Patch to solve missing of Disc Error
        // Reporting
        if(IS_CAPTURE_EVENT)
        {          
         if(IS_CAPTURE_EVENT_ERROR)
         {
          toc_result = CAPTURE_STATUS;
         }
        }
        // Patch to solve missing of Disc Error
        // Reporting
        // End