nand.c

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

              _media_data(options)=kbm_media_data_opt_none;
              _media_data(num_zones)                    = 2;
              _media_data(physical_blocks_per_zone)     = 1024;
              _media_data(logical_blocks_per_zone)      = 1000;
              _media_data(logical_blocks_per_boot_zone) = 1000;
              _media_data(pages_per_block)              = 64;
              _media_data(segments_per_page)            = 4;
              _mcu_register_clr_bits(x_media_sts, kbm_media_sts_sm_256_page) ;
              break;
            }
          default:
            {
              nand_select_media(k_ix_media_nand_int) ;
              sm_identify_media_format() ;
              break;
            }
        }
      }
      break;
    default:
      nand_select_media(k_ix_media_nand_int) ;
      sm_identify_media_format() ;
      break;
  }


  if (x_media_sts & kbm_media_sts_sm_wp )
    _lun_data(media) |= kbm_lun_media_wrprot ;
  else
    _lun_data(media) &= ~kbm_lun_media_wrprot ;

// #ifdef k_interleave_demo
  _media_data(segments_per_page) = g_nand_num_chips;
  g_nand_num_chips = 1;
// #else
  // update the # of zones, assuming all chips are the same at this point
  g_nand_zones_per_chip = _media_data(num_zones) ;
  _media_data(num_zones) *= g_nand_num_chips ;
// #endif
  // setup the map tables (now that the media, and it's instance are known)
  _media_data(log2phy_map) = (t_log2phy_map_ref) _nand_log2phy ;
  _media_data(assign_map)  = (t_assign_map_ref)  _nand_assign_map ;
  _media_data(erase_cache) = (t_erase_cache_ref) _nand_erase_cache_map;

  // enable & init caching mechanisms on per-media basis here
  _media_data(options) |= kbm_media_data_opt_erase_cache;
  // _media_data(options) |= kbm_media_data_opt_write_cache;

  TRACE1(373, nand, 0, "flash chips:    %d", g_nand_num_chips) ;
  TRACE1(374, nand, 0, "zones per chip: %d", g_nand_zones_per_chip) ;
  TRACE1(375, nand, 0, "total zones:    %d", (_media_data(num_zones))) ;
  nand_cmd_reset_device();
  TRACE0(376, nand, 0, "Got here") ;

  return(k_success);

}


//+-----------------------------------------------------------------------------
// Name:
//   nand_check_format()
//
// Declaration:
//   t_result nand_check_format(void) reentrant ;
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//   this is a function
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_check_format(void) reentrant
{
  TRACE0(377, nand, 0, "nand_check_format()") ;

  #if 0
  TRACE0(378, nand, 0, "ERASING ALL FLASH CARDS") ;
  util_safe_erase_media() ;
  #endif


  if ( _lun_is_media_known(g_active_lun) )
    return(k_success);

  // media already identified, but sector map not built yet
  g_addr_rd_phy_blk=0;
  g_addr_page=0;
  _media_data(boot_block)=0;
  _media_data(boot_page)=0;
  _media_data(assign_zone)=0;
  g_addr_zone=0;

  // note:  building a sector map could take 100s of ms
  if ( k_success != map_build_sector_map())
  {
    TRACE0(379, nand, 0, "failed to build sector map") ;
    return(k_error );
  }

  // induce an error bit here under cbw protection, after a sector map has been built
  // util_test_copy_double_bit_ecc(33) ;
  nand_cmd_reset_device() ;
  TRACE0(380, nand, 0, "media identified") ;
  _lun_data(media) &= ~kbm_lun_media_unknown ;

  return(k_success);
}

//+-----------------------------------------------------------------------------
// Name:
//   nand_cmd_check_status()
//
// Declaration:
//   t_result nand_cmd_check_status(void)
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-2.0
//------------------------------------------------------------------------------
t_result nand_cmd_check_status(void) reentrant
{
  uint8 status ;

  _sm_set_rd_cmd(k_sm_read_status);
  status = _sm_data_rd() ;
  trace1(0, sm, 0, "nand_cmd_check_status(): %02x", status ) ;
  if (status&kbm_sm_status_write_failed )
    return(k_error );
  return(k_success );
}
//+-----------------------------------------------------------------------------
// Name:
//   nand_cmd_check_status()
//
// Declaration:
//   t_result nand_cmd_check_status(void)
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-2.0
//------------------------------------------------------------------------------
t_result nand_cmd_check_status_new(void) reentrant
{
  uint8 status ;

  _sm_set_wr_cmd(k_sm_read_status);
  status = _sm_data_rd() ;
  trace1(0, sm, 0, "nand_cmd_check_status(): %02x", status ) ;
  if (status&kbm_sm_status_write_failed )
    return(k_error );
  return(k_success );
}








//+-----------------------------------------------------------------------------
// Name:
//   sm_media_erase_all()
//
// Declaration:
//   t_result sm_media_erase_all(void) reentrant
//
// Purpose:
//   erase all physical blocks on media card, then
//   rebuild sector mapping table
//
// Arguments:
//   none
//
// Return:
//   k_success  - on successful completion
//
// Notes:
//   currently, not a dfa
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_cmd_reset_device(void) reentrant
{
  // reset the chip
  trace0(0, sm, 0, "nand_cmd_reset_device()") ;
  _sm_rd_cmd_begin(k_nand_cmd_reset) ;
  sm_wait_rdy_with_timeout(k_nand_reset_timeout) ;
  _sm_hw_set_rd_standby();
  return(k_success);
}


//+-----------------------------------------------------------------------------
//------------------------------------------------------------------------------
t_result nand_cmd_read_id(void) reentrant
{
  TRACE0(381, nand, 0, "nand_cmd_read_id()");
  _sm_hw_set_rd_cmd();
  _sm_data_wr(k_sm_read_id);
  _sm_hw_set_rd_addr();
  _sm_data_wr(0x00);
  _sm_hw_set_rd_data(0);
  return(k_success);
}

//+-----------------------------------------------------------------------------
//------------------------------------------------------------------------------
t_result nand_cmd_read_id_ex(void) reentrant
{
  TRACE0(382, nand, 0, "nand_cmd_read_id_ex()");
  _sm_hw_set_rd_cmd();
  _sm_data_wr(k_nand_cmd_read_id_ex);
  _sm_hw_set_rd_addr();
  _sm_data_wr(0x00);
  _sm_hw_set_rd_data(0);
  return(k_success);
}

//+-----------------------------------------------------------------------------
// Name:
//   nand_erase_block()
//
// Declaration:
//   t_result nand_erase_block(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_erase_block(void) reentrant
{
  TRACE4(383, nand, 0, "nand_erase_block() - zone:%d wr_phy:%d log:%d page:%d", g_addr_zone, g_addr_wr_phy_blk, g_addr_log_blk, g_addr_page) ;
  nand_select_card() ;
  return(sm_media_erase_block());
}


//------------------------------------------------------------------------------
// read for serial-input.
//------------------------------------------------------------------------------
t_result  nand_page_read_for_data(void) reentrant
{
  TRACE4(384, nand, 0, "nand_page_read_for_data() - zone:%d blk:%d log_blk:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_log_blk, g_addr_page) ;
  _mcu_register_wr(x_smc_stat, kbm_smc_stat_rdy) ;
  _sm_set_rd_cmd(k_sm_read) ;
  _media_set_read_addr();
  _sm_set_rd_cmd(k_nand_cmd_read_for_data) ;
  if (k_success != sm_wait_rdy_with_timeout(k_sm_busy_read_timeout))
  {
    TRACE0(385, nand, 0, "error waiting for data") ;
    nand_cmd_reset_device();
    return(k_error );
  }
  return(k_success );

}

//------------------------------------------------------------------------------
// read for copyback
//------------------------------------------------------------------------------
t_result n2k_page_read_for_copy() reentrant
{
  trace4(0, n2k, 0, "n2k_page_read_for_copy() - zone:%d blk:%d log_blk:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_log_blk, g_addr_page) ;

  _mcu_register_wr(x_smc_stat, kbm_smc_stat_rdy) ;
  _sm_set_rd_cmd(k_sm_read) ;
  _media_set_read_addr();
  _sm_set_rd_cmd(k_nand_cmd_read_for_copy) ;
  if (k_success != sm_wait_rdy_with_timeout(k_sm_busy_read_timeout))
  {
    trace0(0, n2k, 0, "error waiting for data") ;
    nand_cmd_reset_device();
    return(k_error );
  }
  // g_addr_rd_phy_blk is now in the chip's page cache register
  return(k_success );
}


//------------------------------------------------------------------------------
// jump to offset within page in chip cache for data source... page_rd_for_data
// must have previously been called.
//------------------------------------------------------------------------------
t_result n2k_page_set_rd_offset( uint16 offset ) reentrant
{
  trace1(0, n2k, 0, "n2k_page_set_rd_offset() - column:%04X", offset) ;
  _sm_set_rd_cmd(k_nand_cmd_read_offset_addr) ;
  _sm_hw_set_rd_addr();
  _sm_data_wr( _l(offset) ) ;
  _sm_data_wr( _h(offset) ) ;
  _sm_set_rd_cmd(k_nand_cmd_read_offset_data) ;
  _sm_hw_set_rd_data(g_nand_rw_speed);
  return(k_success );
}

//------------------------------------------------------------------------------
// jump to offset within page in chip cache for data dest
//------------------------------------------------------------------------------
t_result n2k_page_set_wr_offset( uint16 offset )  reentrant
{
  trace1(0, n2k, 0, "n2k_page_set_wr_offset() - column:%02X", offset) ;
  _sm_set_wr_cmd(k_nand_cmd_write_cache_data) ;
  _sm_hw_set_wr_addr() ;
  _sm_data_wr( _l(offset) ) ;
  _sm_data_wr( _h(offset) ) ;
  _sm_hw_set_wr_data(g_nand_rw_speed);
  return(k_success );
}

//------------------------------------------------------------------------------
// program page with serial data input
//------------------------------------------------------------------------------
t_result nand_cmd_page_write_cache_data() reentrant
{
  _sm_set_wr_cmd(k_nand_cmd_write_cache_data) ;
  nand_2k_set_write_addr() ;
  return(k_success );
}


//------------------------------------------------------------------------------
// program page with serial data input
//------------------------------------------------------------------------------
t_result nand_cmd_page_program() reentrant
{
  trace0(0, n2k, 0, "nand_cmd_page_program()") ;
  _mcu_register_wr(x_smc_stat, kbm_smc_stat_rdy) ;
  _sm_set_wr_cmd(k_nand_cmd_write_page) ;
  if (k_success != sm_wait_rdy_with_timeout(k_nand_write_page_timeout))
  {
    trace0(0, n2k, 0, "error writing data") ;
    nand_cmd_reset_device();
    return(k_error );
  }

  if (k_success != nand_cmd_check_status())
  {
    trace0(0, n2k, 0, "error failed status check") ;
    nand_cmd_reset_device() ;
    return(k_error );
  }

  trace0(0, n2k, 0, "success") ;
  return(k_success );
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
t_result nand_cmd_cache_program() reentrant
{