controller.c

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

        if (toc_result == BUSY)
        {
          controller_read_toc_fsm.state = FSM_RUN;
          event_in_clear(CAPTURE_STATUS_EVENT);
        }
        else
        {
          CD_UpdateTOCDISCID();
          vl = XAR_FindVolumeByDevice(DEV_CD_ID);
          
          if((!CD_IsDISCIDValid())&&(vl>0))
          { //if different CD and old CD mounted in X_array, delete volume
            XAR_DeleteVolume(vl);
          }

//////////////////////  OT fix copied from 3.1 - remove invalid volumes to save X_array space */
      {
        GRESULT vol = 0; 

#if( HAVE_USB != 0 )
        if (!(DEV_ATTR_READY & SYS_DeviceAttributes(DEV_USB_ID)))
        {
            while(1)  // loop because of multiple partitions
            {
                vol = XAR_FindVolumeByDevice(DEV_USB_ID);
                if (vol > 0)
                {
                    XAR_DeleteVolume(vol);
                }
        	  else 
        		break;
            }
        }
#endif

#if (HAVE_SDC != 0 )
        if (!(DEV_ATTR_READY & SYS_DeviceAttributes(DEV_SDC_ID)))
        {
            while(1)  // loop because of multiple partitions
            {
            	 vol = XAR_FindVolumeByDevice(DEV_SDC_ID);
               if (vol > 0)
               {
                  XAR_DeleteVolume(vol);
               }
        	 else
        	    break;
            }
        }
#endif
        
      }
///////////////////////////////////////////////////////////////////  OT

          if((controller_read_toc_fsm_params.force_execution) 
          || (!CD_IsDISCIDValid()))
          { //if forced TOC cmd or different CD, update TOC info in X_array
            
            // XAR_ReallocateTOC();  
//////////////////////////  fix copied from 3.1 for missing error handling
            if(0>XAR_ReallocateTOC())
            {
                toc_result = E_INSUFFICIENT_MEMORY;
                report_msg_error_mode(ERM_NO_RESOURCES_ERROR);	  //not enough resources	      

                goto toc_alloc_err;       
                
            }
///////////////////////////////////////
            
            CD_UpdateTracksInfo();
          }
          
          if(!CD_IsDISCIDValid())
          { //if different CD, make current and last played position invalid
            AudioBufferResetPosition();   /* BB060926a */
          }

          SYS_SetDeviceAttribute(CD_DEVICE_ID, DEV_ATTR_READY);  // temporary? - to signal CD ready

          if (toc_result == READY)
          {
            rndNextSeed = (TIM1_CNTR + OSAL_time_get()) & 0xFFFF;
            controller_read_toc_fsm.state = FSM_DONE;
          }
          else
          {
toc_alloc_err:          
            controller_read_toc_fsm.state = FSM_ERROR;
            controller_read_toc_fsm.error_reason = toc_result;
          }
          event_in_clear(CAPTURE_STATUS_EVENT);
          if (controller_read_toc_fsm.parent_notify)
          { // inform player (read_toc might have been called from mount_fsm - then we don't inform player)
            CLEAR_ACTIVE_DEV(DEV_CD_ID);       //command finished
            event_set_controller((toc_result & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(DEV_CD_ID,CONTROLLER_CMD_READ_TOC));
          }
        }
      }
      return 0;

    default:
      controller_read_toc_fsm.state = FSM_ERROR;
      return 0;
    }
  } // while
  //return 0; // [RB] TOC is only called on acq event
}


// ******************************* ctr_mount_fs_transition *********************************** //

uint16 ctr_mount_fs_transition(void)
{
  uint8 ctr_filesys_status;
  RETVAL cap_result;
  uint32 EXPECTED_STOP_EVENT;
  t_filesys_cmd_event filesys_cmd_event;

  ctr_active_transitions |= controller_mount_fsm_params.did;

  switch (controller_mount_fsm_params.did)
  {
#if (0 != HAVE_USB)
  case DEV_USB_ID:
    EXPECTED_STOP_EVENT = USB_STOP_EVENT;
    break;
#endif
#if (0 != HAVE_SDC)
  case DEV_SDC_ID:
    EXPECTED_STOP_EVENT = SDC_STOP_EVENT;
    break;
#endif /* HAVE_SDC */
  default: //case DEV_CD_ID:
    EXPECTED_STOP_EVENT = CAPTURE_STATUS_EVENT;
    break;
  }


  if (ctr_stop_flag & controller_mount_fsm_params.did)
  { //mounting device stop required
    if (IS_EXPECTED_STOP_EVENT(EXPECTED_STOP_EVENT))
    { //Device task stopped
      controller_mount_fs_fsm.state = FSM_ERROR;
      controller_mount_fs_fsm.error_reason = STOP_ERROR_REASON;
      if (controller_mount_fs_fsm.parent_notify)
      { // inform player
        CLEAR_ACTIVE_DEV(controller_mount_fsm_params.did);       //command finished
        event_set_controller((controller_mount_fs_fsm.error_reason & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
        //return 0;
      }
      return CTR_TRANSITION_MOUNT_FS;
    }
    return 0;
  }


  while (1)
  {
    print_fsm(&controller_mount_fs_fsm);
    switch (controller_mount_fs_fsm.transition)
    {
    case CTR_MOUNT_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_MOUNT_FSM_IDLE:
      // 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_mount_fs_fsm.transition = CTR_MOUNT_FSM_WAIT_READ_READY_2;
        break;
      }

      controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_WAIT_START;
      return 0; // wait for signal from capture

    case CTR_MOUNT_FSM_WAIT_START:
      // through this part of code we go only when we mount CD

      if (IS_CAPTURE_EVENT)
      { // started or error
        if (IS_CAPTURE_EVENT_READY)
        {
          controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_WAIT_READ_READY_2;
          event_in_clear(CAPTURE_STATUS_EVENT);
          break;
        }
        else if (IS_CAPTURE_EVENT_ERROR)
        { // ERROR - signal upwards
          controller_mount_fs_fsm.state = FSM_ERROR;
          controller_mount_fs_fsm.error_reason = CAPTURE_STATUS;
          event_in_clear(CAPTURE_STATUS_EVENT);
          if (controller_mount_fs_fsm.parent_notify)
          { // inform player
            CLEAR_ACTIVE_DEV(controller_mount_fsm_params.did);       //command finished
            event_set_controller((controller_mount_fs_fsm.error_reason & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
            return 0;
          }
          return CTR_TRANSITION_MOUNT_FS; // PLAY can wait for MOUNT
        }
      }
      return 0;

    case CTR_MOUNT_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

      cap_cmd_event.did = DEV_CD_ID;
      cap_cmd_event.command = CAP_CMD_SET_SPEED;
      cap_cmd_event.command_params.set_speed_params = MOUNT_SPEED;
      //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_mount_fs_fsm.transition = CTR_MOUNT_FSM_START_MOUNT;
        break;
      }

      controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_WAIT_SPEED;
      return 0; // wait for signal from Capture

    case CTR_MOUNT_FSM_WAIT_SPEED:
      if (IS_CAPTURE_EVENT)
      { // speed set or error
        if (IS_CAPTURE_EVENT_READY)
        {
          controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_START_MOUNT;
          event_in_clear(CAPTURE_STATUS_EVENT);
          break;
        }
        else if (IS_CAPTURE_EVENT_ERROR)
        { // ERROR - signal upwards
          controller_mount_fs_fsm.state = FSM_ERROR;
          controller_mount_fs_fsm.error_reason = CAPTURE_STATUS;
          event_in_clear(CAPTURE_STATUS_EVENT);
          if (controller_mount_fs_fsm.parent_notify)
          { // inform player
            CLEAR_ACTIVE_DEV(controller_mount_fsm_params.did);       //command finished
            event_set_controller((controller_mount_fs_fsm.error_reason & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
            return 0;
          }
          return CTR_TRANSITION_MOUNT_FS; // PLAY can wait for MOUNT
        }
      }
      return 0;

    case CTR_MOUNT_FSM_START_MOUNT:
      controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_WAIT_FOR_MOUNT;

#if 1 /* OT fix 11.6.2007 - remove invalid volumes to save X_array space */
      {
        GRESULT vol = 0; 
        if (!(DEV_ATTR_READY & SYS_DeviceAttributes(DEV_USB_ID)))
        {
            while(1)  // loop because of multiple partitions
            {
                vol = XAR_FindVolumeByDevice(DEV_USB_ID);
                if (vol > 0)
                {
                    XAR_DeleteVolume(vol);
                }
        	  else 
        		break;
            }
        }

        if (!(DEV_ATTR_READY & SYS_DeviceAttributes(DEV_SDC_ID)))
        {
            while(1)  // loop because of multiple partitions
            {
            	 vol = XAR_FindVolumeByDevice(DEV_SDC_ID);
               if (vol > 0)
               {
                  XAR_DeleteVolume(vol);
               }
        	 else
        	    break;
            }
        }
      }
#endif
      // send command to FILESYS
      filesys_cmd_event.command = FILESYS_CMD_MOUNT_FS;
      filesys_cmd_event.params.mount_params.devid = controller_mount_fsm_params.did;
      filesys_cmd_event.params.mount_params.force_execution = controller_mount_fsm_params.force_execution;


      ctr_filesys_status = filesys_cmd(&filesys_cmd_event);
      if (ctr_filesys_status == READY)
      {
        if (controller_mount_fs_fsm.parent_notify)
        { // inform player
          CLEAR_ACTIVE_DEV(controller_mount_fsm_params.did);       //command finished
          event_set_controller(READY | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
        }
        controller_mount_fs_fsm.state = FSM_DONE;

        return CTR_TRANSITION_MOUNT_FS; // continue without semaphore signal
      }
      return 0;

    case CTR_MOUNT_FSM_WAIT_FOR_MOUNT:
      if (IS_FILESYS_MOUNT_EVENT)
      { // file system was successfully mounted or error
        RETVAL fsstaus = FILESYS_MOUNT_STATUS;
        event_in_clear(FILESYS_MOUNT_EVENT);
        
/////////////////////////////////////  failure due to low memory, copied from 3.1
        if(fsstaus == E_INSUFFICIENT_MEMORY)
        {
            report_msg_error_mode(ERM_NO_RESOURCES_ERROR);	  //not enough resources
        }
/////////////////////////////////////// OT        
        

        if((controller_mount_fsm_params.did == DEV_CD_ID)
        && ((fsstaus == E_NO_FS_FOUND)
         || (fsstaus == E_FS_TRYNEXTTRACK)))
        {
          if (!(XB_TOC->CDinfo & FIRST_TOC_READABLE))
          {
            if (0x02 == CD_get_bd_type(CD_LastSession(FALSE)))
            {
              CD_set_bd_type(CD_LastSession(FALSE),0x05);
              controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_START_MOUNT;
              break;
            }
          }
          else if (fsstaus == E_FS_TRYNEXTTRACK)
          {
            (void)CD_LastSession(TRUE);
            controller_mount_fs_fsm.transition = CTR_MOUNT_FSM_START_MOUNT;
            break;
          }
        }

        CD_UpdateDISCID();
        if (fsstaus == READY)
        {
          controller_mount_fs_fsm.state = FSM_DONE;
          controller_mount_fs_fsm.error_reason = NO_ERROR_REASON;
        }
        else
        {
          controller_mount_fs_fsm.state = FSM_ERROR;
          controller_mount_fs_fsm.error_reason = fsstaus;
        }

        if (controller_mount_fs_fsm.parent_notify)
        { // inform player
          CLEAR_ACTIVE_DEV(controller_mount_fsm_params.did);       //command finished
          if(controller_mount_fs_fsm.state == FSM_ERROR)
            event_set_controller((controller_mount_fs_fsm.error_reason & 0xFFFF) | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
          else
            event_set_controller(READY | SET_DEV_CMD_TYPE_OF_CTR_STATUS(controller_mount_fsm_params.did,CONTROLLER_CMD_MOUNT_FS));
          return 0;
        }
        return CTR_TRANSITION_MOUNT_FS;
      }
      return 0;
    default:
      controller_mount_fs_fsm.state = FSM_ERROR;
      return 0;
    }
  }
}

// ****************************** ctr_init_transition ************************************ //
/*
void ctr_init_transition(void)
{

  switch (ctr_init_fsm)
  {
    case CTR_INIT_FSM_IDLE:
      ctr_init_fsm = CTR_INIT_FSM_WAIT_TO_STOP;
    case CTR_INIT_FSM_WAIT_TO_STOP:
      if (controller_internal_flags & CTR_INTERNAL_CHILDERN_RUN)
      {
        // cannot init before stop
        break;
      }
      ctr_init_fsm = CTR_INIT_FSM_INITALIZING;
    case CTR_INIT_FSM_INITALIZING: