media.c

<B>SMSC USB2.0 Flash硬盘驱动源码</B>

// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_phy2log(void) reentrant 
{
  TRACE0(332, media, 0, "+media_phy2log()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_bind_log2phy()
//
// Declaration:
//   t_result media_bind_log2phy(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_bind_log2phy(void) reentrant
{
  TRACE0(333, media, 0, "+media_bind_log2phy()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_set_phyblock_failed()
//
// Declaration:
//   t_result media_set_phyblock_failed(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_set_phyblock_failed(void) reentrant
{
  TRACE0(334, media, 0, "+media_set_phyblock_failed()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_is_phyblock_ok()
//
// Declaration:
//   t_result media_is_phyblock_ok(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_is_phyblock_ok(void) reentrant
{
  TRACE0(335, media, 0, "+media_is_phyblock_ok()") ;
  return k_false ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_is_phyblock_blank()
//
// Declaration:
//   t_result media_is_phyblock_blank(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_is_phyblock_blank(void) reentrant
{
  TRACE0(336, media, 0, "+media_is_phyblock_blank()") ;
  return k_false ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_read_extra_data()
//
// Declaration:
//   t_result media_read_extra_data(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_read_extra_data(void) reentrant
{
  TRACE0(337, media, 0, "+media_read_extra_data()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_write_extra_data()
//
// Declaration:
//   t_result media_write_extra_data(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_write_extra_data(void) reentrant
{
  TRACE0(338, media, 0, "+media_write_extra_data()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_clear_extra_data()
//
// Declaration:
//   void media_clear_extra_data(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result  media_clear_extra_data(void) reentrant
{
  TRACE0(339, media, 0, "+media_clear_extra_data()") ;
  return k_error ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_resolve_conflict()
//
// Declaration:
//  t_result sm_media_resolve_conflict(void) reentrant
//
// Purpose:
//  provide common conflict resolution algorithm (checking for
//  errors in the extra-data...  if both phyblocks have a valid
//  binding according to the extra data, then the derived 
//  method will be called to pick one.
//
// Arguments:
//  - see Notes
//
// Return:
//  k_error always
//
// Notes:
//  when called, 
//    g_addr_rd_phy_blk contains one of the bindings, 
//    g_addr_wr_phy_blk contains the original mapping 
//
//  before returning, ensure:
//    g_addr_rd_phy_blk should contain the correct mapping
//    g_addr_wr_phy_blk should contain the block to be erased (or not used)
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_resolve_conflict(void) reentrant 
{
  return map_resolve_conflict() ;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_write_one_sector()
//
// Declaration:
//   t_result sm_media_write_one_sect(uint8 *buf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
#if 0
t_result media_write_one_sector(uint8 *buf) reentrant
{
  unsigned int retry;

  _media_data(sector_buffer) = buf ;
  
  trace0(0, sm, 0, "media_write_one_sect()") ;
  if (k_success == _media_write_sector() )
    return k_success;

  for (retry=1; retry<2; retry++)
  {
    if (k_success != map_reassign_block_head())
      continue;
    
    if (k_success == _media_write_sector())
      return k_success;
    k_error ;
  }

  if (k_success != map_erase_wr_blk())
    return k_error ;
  _lun_data(media) |= kbm_lun_media_unknown ;
  return k_error ;
}
#endif

//+-----------------------------------------------------------------------------
//+-----------------------------------------------------------------------------
t_result media_copy_block(uint8 count) reentrant
{
  t_result result;
  t_bool   read_error;

  TRACE3(340, media, 0, "media_copy_block() src:%d dst:%d cnt:%d", g_addr_rd_phy_blk, g_addr_wr_phy_blk, count);
  read_error=k_false;
  while(count--)
  {
    result=_media_copy_sector();
    if(k_success!=result)
    {
      if(k_media_copy_error_src==result)
      {
        TRACE0(341, media, 0, "read error detected.  continue copying") ;
        read_error=k_true;
      }
      else
      {
        TRACE0(342, media, 0, "fatal error occured while copying.  aborting copy_block()") ;
        return k_error;
      }
    }
    g_addr_page++;
  }

  return (read_error?k_media_copy_error_src:k_success);
}

//+-----------------------------------------------------------------------------
// Name:
//   media_copy_block_head()
//
// Declaration:
//   t_result media_copy_block_head(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_copy_block_head(void) reentrant
{
  uint8 page=g_addr_page;
  TRACE0(343, lun, 0, "media_copy_block_head()") ;
  // _stack_check();
  g_addr_page=0;
  return media_copy_block(page);
}

//+-----------------------------------------------------------------------------
// Name:
//   map_copy_block_tail()
//
// Declaration:
//   t_result map_copy_block_tail(void) reentrant ;
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_copy_block_tail(void) reentrant
{
  uint8 page=g_addr_page;
  TRACE0(344, media, 0, "media_copy_block_tail()") ;
  return media_copy_block( (_media_data(pages_per_block)-page));
}


//+-----------------------------------------------------------------------------
// Name:
//   media_copy_sector()
//
// Declaration:
//   t_result media_copy_sector(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_copy_sector(void) reentrant
{
  int16 i;

  TRACE3(345, media, 0, "media_copy_sector() - src_blk:%d dst_blk:%d page:%d ", g_addr_rd_phy_blk, g_addr_wr_phy_blk, g_addr_page) ;

  if ( g_addr_wr_phy_blk == k_block_free )
  {
    TRACE0(346, media, 0, "error:  no destination block") ;
    return k_error ;
  }

  // read or fabricate data
  _media_data(sector_buffer)=g_sector_buffer;
  if (g_addr_rd_phy_blk != k_block_free )
  {
    if (k_success != _media_read_sector() )
      return k_error ;
  }
  else
  {
    TRACE0(347, media, 0, "src blk blank.  copying blank sector") ;
    for (i=0; i<k_sm_sector_sz; i++)
      g_sector_buffer[i]=0xff ;
    _media_clear_extra_data() ;
  }
  
  // bind current logical block to new physical block
  _media_bind_log2phy() ; 

  // write sector out to new location
  if (k_success != _media_write_sector() ) 
  {