media.c

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

    _lun_data(media) |= kbm_lun_media_unknown ;
    TRACE0(348, media, 0, "copy failed during write") ;
    return k_error ;
  }
  
  return k_success;
}

//+-----------------------------------------------------------------------------
// Name:
//   media_set_read_addr()
//
// Declaration:
//   t_result media_erase_card() reentrant
//               media_set_read_addr
// Purpose:
//   set media-specific address from internal zone/rd_phy_blk/sector addres
//
// Arguments:
//  TBD
//
// Return:
//  k_success always
//
// Notes:
//  TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_set_read_addr() reentrant 
{
  TRACE0(349, media, 0, "media_set_read_addr() - virtual function does nothing") ;
  return k_success ;
}


//+-----------------------------------------------------------------------------
// Name:
//   media_set_write_addr()
//
// Declaration:
//   t_result media_set_write_addr() reentrant
//
// Purpose:
//   set media-specific address from internal zone/wr_phy_blk/sector addres
//
// Arguments:
//  TBD
//
// Return:
//  k_success always
//
// Notes:
//  TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_set_write_addr() reentrant 
{
  TRACE0(350, media, 0, "media_set_write_addr() - virtual function does nothing") ;
  return k_success ;
}


//+-----------------------------------------------------------------------------
// Name:
//   media_set_erase_addr()
//
// Declaration:
//   t_result media_set_erase_addr() reentrant
//
// Purpose:
//   set media-specific address from internal zone/wr_phy_blk
//
// Arguments:
//  TBD
//
// Return:
//  k_success always
//
// Notes:
//  The block to be erased should be in g_addr_wr_phy_blk before this 
//  function is called
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_set_erase_addr() reentrant 
{
  TRACE0(351, media, 0, "media_set_erase_addr() - virtual function does nothing") ;
  return k_success ;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
t_result media_recover_bad_block() reentrant
{
  #if (k_log_lun_sm<k_max_log_lun)||(k_log_lun_nand<k_max_log_lun)
  uint16 i ;
  #endif
  t_result result ;

  if(g_active_media == k_ix_media_ms)
  {
    return _media_erase_block() ;
  }
  
  result = k_error ;

#if (k_log_lun_sm<k_max_log_lun)||(k_log_lun_nand<k_max_log_lun)

  // smart media/nand recovery only
  // test for factor-marked bad... redt data of all 0's is the best test
  for(i=0; i<16;i++)
  {
    if(x_sm_redt_data[i] != 0x00)
      result = k_success ;
  }
  
  // an error indicates a factory-marked-bad candidate
  if(k_success != result)
  {
    // check to see if the block is all 00's too... if so, don't touch it
    nand_rd_va2pa() ;
    _media_data(sector_buffer) = g_sector_buffer ;

    result = _media_read_sector() ;
    if(k_success != result)
      return result ;

    result = k_error ;
    for(i=0;i<512;i++)
    {
      if(g_sector_buffer[i] != 0x00)
      {
        result = k_success ;
      }
    }

    if(k_success != result)
    {
      // factory-marked-bad block... bail
      return result ;
    }
  }
#endif

  // do the block erase here
  result = _media_erase_block() ;
#if 0 
  if(k_success != result)
    return result ;

  // write first pattern
  for(g_addr_page;g_addr_page < _media_data(pages_per_block);g_addr_page++)
  {
    result=util_wr_verify_page_55() ;
    if(result != k_success)
      return result ;
  }

  g_addr_page=0 ;
  result = _media_erase_block() ;
  for(g_addr_page;g_addr_page < _media_data(pages_per_block);g_addr_page++)
  {
    result=util_wr_verify_page_aa() ;
    if(result != k_success)
      return result ;
  }

  g_addr_page=0;
  result = _media_erase_block() ;
#endif
  // technically, should write the pattern here for save erase
  return result ;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void media_safe_erase_block() reentrant
{
  g_addr_rd_phy_blk=g_addr_wr_phy_blk;

  if ((!g_addr_zone) && (g_addr_rd_phy_blk <= _media_data(boot_block)))
  {
    trace2(0, util, 0, "zone %d block %d - reserved.  not erased", g_addr_zone, g_addr_rd_phy_blk) ;
    return;
  }
  g_addr_page=0 ;
  _media_read_extra_data() ;
  if( _media_is_phyblock_ok() )
  {
    if (_media_is_phyblock_blank() )
    {
      // not bad... not written... don't erase
      return;
    }
    if (k_success == _media_erase_block())
    {
      return;
    }
  }
  
  // attempt to recover blocks not marked bad by the factory
  if( k_success == media_recover_bad_block() )
  {
    trace2(0, util, 0, "zone %d block %d - restored", g_addr_zone, g_addr_wr_phy_blk) ;
    return;
  }
  
  trace2(0, util, 0, "zone %d block %d - block is bad",g_addr_zone, g_addr_wr_phy_blk) ;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void media_safe_erase_zone() reentrant
{
  trace1(0, util, 0, "Erasing Zone %d ------", g_addr_zone) ;

  for(g_addr_wr_phy_blk=0;
      g_addr_wr_phy_blk<_media_data(physical_blocks_per_zone);
      g_addr_wr_phy_blk++)
  {
    media_safe_erase_block() ;
  }
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void media_safe_erase_all() reentrant
{
  trace0(0, util, 0, "util_safe_erase_media() - erase all blocks not explicitly marked 'bad' by the factory") ;

  for(g_addr_zone=0;
      g_addr_zone<_media_data(num_zones);
      g_addr_zone++)
  {
    media_safe_erase_zone() ;
  }
}

//+-----------------------------------------------------------------------------
// Name:
//   media_dfa_erase()
//
// Declaration:
//   void media_dfa_erase(void) reentrant ;
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
#define kbm_media_erase_pwd 0x01
void nand_boot_seek() reentrant;
void media_dfa_erase(void) reentrant
{
  uint8 zone;
  TRACE0(352, media, 0, "media_dfa_erase_media()");
  _lun_data(sensep) = &sense_none;

  // make sure media is not writeprotected before we erase it
  if(_lun_data(media) & kbm_lun_media_wrprot)
  {
    _lun_data(sensep) = &sense_write_protect;
    thread_return_dfa(k_command_failed);
  }

  zone=g_bot_cbw.cdb[2];
  TRACE1(353, media, 0, "media_dfa_erase zone:%d", zone) ;
  if( (zone==0xff)||(zone==0))
  { 
    if(!zone)
    {
      g_addr_zone=0;
      media_safe_erase_zone();
    }
    else
    {
      // erasing media
      media_safe_erase_all();
    }
    TRACE0(354, media, 0, "erased zone") ;
#ifdef k_opt_password
    // make sure we know where the boot sector is first...
    nand_boot_seek();
    if((g_bot_cbw.cdb[3])&(kbm_media_erase_pwd))
    {
      uint8 i;
      nvstore_write_enable();
      for(i=k_ix_password;i<k_ix_password+k_sz_password;i++)
        nvstore_write(i, 0xff);
      nvstore_write_disable();
      g_password_validated=k_yes;
    }
#endif
  }
  else if(zone<_media_data(num_zones))
  {
    g_addr_zone=zone;
    media_safe_erase_zone();
  }
  else
  {
    _lun_data(sensep)=&sense_illegal_address;
    _thread_return_dfa(k_command_failed);
  }
  _thread_return_dfa(k_command_passed);
}

//+-----------------------------------------------------------------------------
// Name:
//   media_dfa_report_media_geometry()
//
// Declaration:
//   void nand_dfa_report_media_geometry(void) reentrant ;
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void media_dfa_report_media_geometry(void) reentrant
{
  TRACE0(355, lun, 0, "nand_dfa_report_media_geometry()");

  _lun_data(sensep) = &sense_none;
  // media type code
  g_sector_buffer[0]=g_active_media;
  // cache options
  g_sector_buffer[1]=_media_data(options);
  // total zones
  g_sector_buffer[2]=_media_data(num_zones);
  // zones per card
#if (k_log_lun_nand<k_max_log_lun)
  if((g_active_media==k_ix_media_nand)||(g_active_media==k_ix_media_nand_2k))
    g_sector_buffer[3]=g_nand_zones_per_chip ;
  else
#endif
    g_sector_buffer[3]=_media_data(num_zones);
  // phy blocks per zone
  g_sector_buffer[4]= _h(_media_data(physical_blocks_per_zone)) ;
  g_sector_buffer[5]= _l(_media_data(physical_blocks_per_zone));
  // log blocks per zone
  g_sector_buffer[6]=_h(_media_data(logical_blocks_per_zone));
  g_sector_buffer[7]=_l(_media_data(logical_blocks_per_zone));
  // log blocks per boot zone
  g_sector_buffer[8]=_h(_media_data(logical_blocks_per_boot_zone));
  g_sector_buffer[9]=_l(_media_data(logical_blocks_per_boot_zone));
  // pages per block
  g_sector_buffer[10]=_media_data(pages_per_block);
  // sectors per page
  g_sector_buffer[11]=_media_data(segments_per_page);

  // send it
  mscbot_tx_data_buffer(g_sector_buffer, 12);
  _thread_return_dfa(k_command_passed);
}

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

//+-----------------------------------------------------------------------------
// Name:
//   ms_media_is_phyblock_reserved()
//
// Declaration:
//   t_result ms_media_is_phyblock_reserved() reentrant
//
// Purpose:
//   tells mapper whether or not a block is reserved (i.e. boot area) or
//   usable by mapper & user.  
//
// Arguments:
//
// Return:
//  k_true  if physical zone/block can be a user-accessible block
//  k_false if physical block should be ignored by the mapper for everything
//
// Notes:
//  a reserved block is NOT a factory or user-marked bad block.  it is a block reserved
//  for storing private data or boot information.  (i.e. boot blocks, boot area, etc.)
//  blocks marked bad by the factory will be detected in a subsequent call
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result media_is_phyblock_reserved(void) reentrant
{
  TRACE0(357, media, 0, "media_is_phyblock_reserved()");
  return k_false;
}

//---eof------------------------------------------------------------------------