capture.c

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

/******************************************************************************/
/* Function:  cap_process_sector_request                                      */
/*                                                                            */
/*! \brief    process new sector request
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

void cap_process_sector_request(void)
{
  uint32 req_lba;
  uint32 req_sector_count;
  int32 Jump_ROM_Mode;//DR060912 Jump Variable used during FS/Playlist Access
  uint16 read_ptr_pos;
  req_lba = local_cap_cmd_event.command_params.xfer_params.sector_start;

  if (cap_esp_buf.first.lba <= req_lba
   && cap_esp_buf.last.lba > req_lba
   && (cap_esp_buf.first.lba != cap_esp_buf.last.lba)
   && !local_cap_cmd_event.command_params.xfer_params.update_process)
  {
    /* Requested sectors are in buffer.
       - Update cap_esp_buf.fill 0: No needs to capture (Just read controller handling).
                                 1: Needs to capture.
       - Update actual re-start secctor address for captuing => local_cap_cmd_event.command_params.xfer_params.sector_start
       - Keep cap_esp_buf.first/last information.
       - Update next read pointer for the case if force_execution == '1' by return value.
    */
    read_ptr_pos = cap_esp_search_buffer();
  }
  else
  {
    local_cap_cmd_event.command_params.xfer_params.update_process = 0;

    /* Requested sectors are not in buffer. */
    cap_esp_buf.fill = 1;

    /* Keep local_cap_cmd_event.command_params.xfer_params.sector_start */

    if (cap_status.write.xfer_condition & CAP_ESP_WAKEUP_TO_RESTART)
    {
      /* This is re-start sequence & re-start capturing at (end of buffered sector + 1).
         Don't need to updat cap_esp_buf_first/last information. */
    }
    else // if( !(cap_status.write.xfer_condition & CAP_ESP_WAKEUP_TO_RESTART) )
    {
#if (1 == HAVE_SHOCK_MEMORY)
      if (ADPCM_ON == cap_config.adpcm)
      {
        if (DATA_TYPE_CDDA == local_cap_cmd_event.command_params.xfer_params.data_type)
        {
          OIF_SOFT_RST.field.adpcm_enc_rst = 1;
          cap_status.write.xfer_condition |= CAP_ESP_MARK_FIRST_XFER;
          OIF_SOFT_RST.field.adpcm_enc_rst = 0;
        }
      }
#endif
      //DR060912 Make a decision whether to Jump or wait in ROM Mode based on Jump_ROM_Mode Value
      Jump_ROM_Mode = local_cap_cmd_event.command_params.xfer_params.sector_start - cap_esp_buf.last.lba;	

      if((local_cap_cmd_event.command_params.xfer_params.Play_Mode == 1)
	 || ((0 == cap_esp_buf.first.lba) && (0 == cap_esp_buf.last.lba))
	 || ((Jump_ROM_Mode < 0) || (Jump_ROM_Mode > CAP_ROM_MODE_JUMP)))
      {
      /* Reset cap_esp_buf.first/last information */
      cap_esp_buf.first.lba = local_cap_cmd_event.command_params.xfer_params.sector_start;
      cap_esp_buf.first.pos = cap_status.write.xfer_pointer;

      /* cap_esp_buf.last information show next lba/position to capture. */
      cap_esp_buf.last.lba = local_cap_cmd_event.command_params.xfer_params.sector_start;
      cap_esp_buf.last.pos = cap_status.write.xfer_pointer;
      }

      /* On new capture, it uses cap_status.write.last_good_lba more frequent. Should reset it. */
      cap_status.write.last_good_ptr = cap_status.write.xfer_pointer;
      cap_status.write.last_good_lba = local_cap_cmd_event.command_params.xfer_params.sector_start;
    }

    /* Store next read ponter for the case if force_execution == '1' */
    read_ptr_pos = cap_status.write.xfer_pointer;
  }

  /* Store actual sector stop address. Should be done only 1 time. */
  if (!(cap_status.write.xfer_condition & CAP_ESP_WAKEUP_TO_RESTART))
  {
    cap_status.write.xfer_sector_end = local_cap_cmd_event.command_params.xfer_params.sector_stop;
  }

  /* caculate actual requested number of sectors */
  req_sector_count = local_cap_cmd_event.command_params.xfer_params.sector_stop
                   - local_cap_cmd_event.command_params.xfer_params.sector_start
                   + 1;

  /* Actual requested number of sectors is less than 3 ? (Need at least 3 sectors) */
  if (req_sector_count < 3 && cap_esp_buf.fill)
  {
    local_cap_cmd_event.command_params.xfer_params.sector_stop = local_cap_cmd_event.command_params.xfer_params.sector_start
                                                                   + 2; /* At least 3 sectors for BD_START/BD_STOP difference */
    cap_status.write.xfer_condition |= CAP_ESP_WARNING_BACK_PTR;  /* Set the flag to warn that margin will be reduced. */
  }
  else
  {
    cap_status.write.xfer_condition &= ~CAP_ESP_WARNING_BACK_PTR;
  }

  if (local_cap_cmd_event.command_params.xfer_params.force_execution)
  {
#if (1 == HAVE_SHOCK_MEMORY)
    if (ADPCM_ON == cap_config.adpcm)
    {
      if (DATA_TYPE_CDDA == local_cap_cmd_event.command_params.xfer_params.data_type)
      {
        OIF_SOFT_RST.field.adpcm_enc_rst = 1;
        cap_status.write.xfer_condition |= CAP_ESP_MARK_FIRST_XFER;
        OIF_SOFT_RST.field.adpcm_enc_rst = 0;
      }
    }
#endif

    /* Force execution : Read pointer is reset by write pointer */
    cap_status.read.xfer_pointer = read_ptr_pos;
    cap_status.read.xfer_condition &= ~CAP_ESP_READ_STARTUP_DONE; /* Clear the bit */

    cap_status.write.last_good_ptr = cap_status.write.xfer_pointer;
    cap_status.write.last_good_lba = local_cap_cmd_event.command_params.xfer_params.sector_start;

    cap_esp_check_margin();

    local_cap_cmd_event.command_params.xfer_params.force_execution = 0;
  }
  else
  {
    /* Not Force execution */
    /* Don't update cap_esp_buf.first/last information */
  }
}


/******************************************************************************/
/* capture fsm management                                                     */
/******************************************************************************/

/******************************************************************************/
/* Function:  cap_error_reset                                                 */
/*                                                                            */
/*! \brief    cap task error reset
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

void cap_error_reset(void)
{
  cap_status.count.g_retries = CAP_MAX_RETRIES;
}

/******************************************************************************/
/* Function:  cap_servo_retries_reset                                         */
/*                                                                            */
/*! \brief    cap task servo retries count reset
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

void cap_servo_retries_reset(void)
{
  cap_status.count.g_servo_retries = CAP_MAX_SERVO_RETRIES;
}

/******************************************************************************/
/* Function:  cap_get_subcode_data                                            */
/*                                                                            */
/*! \brief    subcode reading
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/

uint32 cap_get_subcode_data(uint32 *InputBufferPtr)
{
  uint8 *SubQPtr;
  //BLOCK_INFO_STRUCT *BlockInfoPtr; // [RB] unused
  uint32 ret_msf;

#if (1 == HAVE_SHOCK_MEMORY)
  if (ADPCM_ON == cap_config.adpcm)
  {
    SubQPtr = (uint8 *) (InputBufferPtr + (0x24C >> 2));
    //BlockInfoPtr = (BLOCK_INFO_STRUCT *) (InputBufferPtr + (604 >> 2));
  }
  else
#endif
  {
    SubQPtr = (uint8 *) (InputBufferPtr + (0x930 >> 2));
    //BlockInfoPtr = (BLOCK_INFO_STRUCT *) (InputBufferPtr + (2464 >> 2));
  }

  ret_msf = NOT_VALID_SUBCODE;

  

  //if (BlockInfoPtr->SubcodeStatus & BLOCK_INFO_CRC_OK)
  if(CrcCheck(SubQPtr))
  {
    switch (SubQPtr[0] & 0x0F)  /* Control Address */
    {
    case 0x01:
      /* Mode 1 */
      if (0 != SubQPtr[1])    /* Tno */
      {
        /* Send good LBA */
        ret_msf = msf_2_sid(SubQPtr[7], SubQPtr[8], SubQPtr[9], BCD);
      }
      break;

    default:
      break;
    }
  }  /* if(BlockInfoPtr->SubcodeStatus & BLOCK_INFO_CRC_OK) */

  return ret_msf;
}

/******************************************************************************/
/* Function:  cap_get_lba_address                                             */
/*                                                                            */
/*! \brief    Get LBA address at local_xfer_pointer in cap_input_buffer
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
uint32 cap_get_lba_address(uint16 local_xfer_pointer, uint8 data_type)
{
  uint32 local_good_lba;
  uint8 *cap_input_buffer;

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);
  if (DATA_TYPE_CDDA == data_type)
  {
    local_good_lba = cap_get_subcode_data((uint32 *) cap_input_buffer);
  }
  else   /* cd rom */
  {
    /* tbd : Temporary solution until fix strategy for cddrom error correction. */
    if (*(cap_input_buffer + 15) <= 2)
    {
      local_good_lba = msf_2_sid(*(cap_input_buffer + 12), \
                                 *(cap_input_buffer + 13), \
                                 *(cap_input_buffer + 14), BCD);
    }
    else
    {
      local_good_lba = NOT_VALID_SUBCODE;
    }
  }

  return local_good_lba;
}

/******************************************************************************/
/* Function:  cap_esp_set_dummy_address                                       */
/*                                                                            */
/*! \brief    Store dummy sector ID.
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
void cap_esp_set_dummy_address(uint16 local_xfer_pointer, uint32 valid_address)
{
  uint8 *cap_input_buffer;

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);          
  
  if (DATA_TYPE_CDDA == cap_status.write.data_type)
  {
#if (1 == HAVE_SHOCK_MEMORY)
    if (ADPCM_ON == cap_config.adpcm)
    {
      /* Store dummy SID into last 3 bytes in this sector. [CDDA] */
      *(cap_input_buffer + 788) = (valid_address >> 16) & 0xFF;
      *(cap_input_buffer + 790) = (valid_address >> 8) & 0xFF;        
      *(cap_input_buffer + 792) = (uint8)valid_address & 0xFF;
      *(cap_input_buffer + 794) = CAP_INVALID_SECTOR_MARK;
    }
    else
#endif
    {                         
      /* Store dummy SID into last 3 bytes in this sector. [CDDA] */        
      *(cap_input_buffer + 2552) = (valid_address >> 16) & 0xFF;
      *(cap_input_buffer + 2554) = (valid_address >> 8) & 0xFF;        
      *(cap_input_buffer + 2556) = (uint8)valid_address & 0xFF;
      *(cap_input_buffer + 2558) = CAP_INVALID_SECTOR_MARK;
      cap_status.count.chk_lba++; /* Count invalid sector on CDDA [FH] 25/Sep/2007 */
    }
  }
  else   /* cd rom */
  {
    /* Store dummy SID into first 3 bytes in this sector. [CDROM] */
    *(cap_input_buffer)     = CAP_INVALID_SECTOR_MARK;
    *(cap_input_buffer + 2) = (valid_address >> 16) & 0xFF;
    *(cap_input_buffer + 4) = (valid_address >> 8) & 0xFF;        
    *(cap_input_buffer + 6) = (uint8)valid_address & 0xFF;
  }

}

/******************************************************************************/
/* Function:  cap_esp_get_valid_address                                       */
/*                                                                            */
/*! \brief    Read dummy sector ID.
 *  \param
 *  \return
 *  \remark
 */
/******************************************************************************/
uint32 cap_esp_get_valid_address(uint16 local_xfer_pointer, uint8 data_type)
{
  uint32 local_good_lba;
  uint8 *cap_input_buffer;

  cap_input_buffer = CAP_INPUT_BUFFER + (local_xfer_pointer * CAP_INPUT_SECTOR_SIZE);

  if (DATA_TYPE_CDDA == data_type)
  {
#if (1 == HAVE_SHOCK_MEMORY)
    if (ADPCM_ON == cap_config.adpcm)
    {
      if (*(cap_input_buffer + 794) == CAP_INVALID_SECTOR_MARK)
      {
        /* Read dummy SID from last 3 bytes in this sector. [CDDA] */
        local_good_lba =   *(cap_input_buffer + 788) << 16 
                         + *(cap_input_buffer + 790) << 8
                         + *(cap_input_buffer + 792);

        return local_good_lba;
      }
    }
    else
#endif
    {                         
      if (*(cap_input_buffer + 2558) == CAP_INVALID_SECTOR_MARK)
      {
        /* Read dummy SID from last 3 bytes in this sector. [CDDA] */ 
        local_good_lba =   (*(cap_input_buffer + 2552) << 16)
                         + (*(cap_input_buffer + 2554) << 8)
                         +  *(cap_input_buffer + 2556);

        return local_good_lba;
      }
    }
  }
  else   /* cd rom */
  {
    if (*(cap_input_buffer) == CAP_INVALID_SECTOR_MARK)
    {
      /* Read dummy SID from first 3 bytes in this sector. [CDROM] */
      local_good_lba =   (*(cap_input_buffer + 2) << 16)