nand.c

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

// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_dfa_write(void) reentrant
{
  TRACE0(398, nand, 0, "nand_dfa_write()");

  // check for write protection change
  if ( nand_check_wp() )
  {
    TRACE0(399, nand, 0, "error:  write protection state changed") ;
    __thread_return_dfa(k_error) ;
  }

  // check for write protection state
  if ( _mcu_register_rd(x_media_sts)&kbm_media_sts_sm_wp)
  {
    TRACE0(400, nand, 0, "error:  write protection enabled") ;
    _lun_data(sensep) = &sense_media_change ;
    __thread_return_dfa(k_error) ;
  }

  _fmc_set_options(0);
  _fmc_set_timeout(10000);

  if (k_ix_media_nand == g_ix_media_nand)
  {
    TRACE0(401, nand, 0, "preparing for 512-byte per page writes") ;
    _fmc_set_callback(sm_write_begin_xfer, sm_write_end_xfer,
                      nand_write_begin_first_split, sm_write_end_split,
                      sm_write_begin_burst, fmc_dflt_callback, sm_write_end_burst);
  }
  else if (k_ix_media_nand_int == g_ix_media_nand)
  {
    _fmc_set_callback(nand_int_write_begin_xfer, nand_int_write_end_xfer,
                      nand_write_begin_first_split, nand_int_write_end_split,
                      nand_int_write_begin_burst, fmc_dflt_callback, nand_int_write_end_burst);

  }
  else
  {
    trace0(0, n2k, 0, "preparing for 2048-byte-per-page writes") ;
    _fmc_set_callback(n2k_write_begin_xfer, sm_write_end_xfer,
                      nand_write_begin_first_split, n2k_write_end_split,
                      n2k_write_begin_burst, fmc_dflt_callback, n2k_write_end_burst);
  }
  dfa_lun_write();
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_power_dn()
//
// Declaration:
//   t_result sm_power_dn() 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_power_dn() reentrant
{
  TRACE0(402, nand, 0, "nand_power_dn()") ;
  _sm_hw_set_rd_standby();
  return(k_success );
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_power_up()
//
// Declaration:
//  t_result sm_power_up(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_power_up(void) reentrant
{
  TRACE0(403, nand, 0, "nand_power_up()");
  return(k_success );
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_reset_controller()
//
// Declaration:
//   void sm_reset_controller(void) reentrant
//
// Purpose:
//   erase all physical blocks on media card, then
//   rebuild sector mapping table
//
// Arguments:
//   none
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_reset_controller(void) reentrant
{
  TRACE0(404, nand, 0, "nand_reset_controller()");
}

//+-----------------------------------------------------------------------------
// Name:
//   dfa_sm_identify_media
//
// Declaration:
//   void dfa_sm_identify_media(void);
//
// Purpose:
//   determine if smart media is present the device and if so,
//   determine max lba and lb size
//
// Arguments:
//   none
//
// Return:
//   none
//
// Notes:
//   This is a DFA
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_dfa_identify_media(void) reentrant
{
  TRACE0(405, nand, 0, "nand_dfa_identify_media()");
  _lun_data(media) |= kbm_lun_media_unknown ;

  if (k_success != nand_check_format())
  {
    TRACE0(406, nand, 0, "nand_check_format() returned an error!") ;
    _thread_return_dfa(k_error) ;
  }

  _lun_data(capacity.lba_max.u32) = _media_data(num_zones) * (uint32) _media_data(logical_blocks_per_zone) * (uint32) _media_data(pages_per_block)* (uint32) _media_data(segments_per_page) ;
  _lun_data(capacity.lba_sz.u32)  = 512 ;

  if ( x_media_sts & kbm_media_sts_sm_256_page )
    _lun_data(capacity.lba_max.u32) /= 2 ;
  if ( k_ix_media_nand_2k == g_active_media)
    _lun_data(capacity.lba_max.u32) *= 4 ;

  _lun_data(capacity.lba_max.u32) -= (uint32) 1 ;

  // media is now known
  _lun_data(media) &= ~kbm_lun_media_unknown;
  _lun_data(sensep) = &sense_media_change;

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

#if 1


  // check attributes
  if (g_dev_attr_lo&kbm_attr_lo_sm_timing)
  {
    TRACE0(407, nand, 0, "Forcing Smart Media-Compatible Cycle Timing on NAND flash") ;
    g_nand_rw_speed=0;
  }
  else
  {
    TRACE0(408, nand, 0, "Enabling fast cycle time on NAND flash") ;
    g_nand_rw_speed=kbm_sm_mode_fast_cycle_time;
  }
#else
  g_nand_rw_speed=0;
#endif
  TRACE2(409, nand, 0, "nand capacity:  lba_max:%04x%04x lba_sz:00000200", _hw(_lun_data(capacity.lba_max.u32)), _lw(_lun_data(capacity.lba_max.u32))) ;


  thread_return_dfa(k_success) ;
}

//+-----------------------------------------------------------------------------
// Name:
//   TBD
//
// Declaration:
//   TBD
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   This is a DFA, not a FUNCTION.
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_dfa_initialize_media() reentrant
{
  TRACE0(410, nand, 0, "nand_dfa_initialize_media()");
  _lun_data(media) &= ~kbm_lun_media_changed;
  TRACE2(411, lun, 0, "_lun_data(%d, media)=%02x", g_active_media, _lun_data(media));
  _thread_return_dfa(k_success);
}

//+-----------------------------------------------------------------------------
// Name:
//   TBD
//
// Declaration:
//   TBD
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   This is a DFA, not a FUNCTION.
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_dfa_reset_media() reentrant
{
  TRACE0(412, nand, 0, "nand_dfa_reset_media()");
  _thread_return_dfa(k_success);
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_initialize_controller()
//
// Declaration:
//   void sm_initialize_controller(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_initialize_controller(void) reentrant
{
  uint16 i;
  TRACE0(413, nand, 0, "nand_initialize_controller()") ;

  // initialize _lun_data
  memcpy(_lun_data(device_id), "HD", k_lun_max_devid_sz) ;
  _lun_data(media) &=~ kbm_lun_media_unknown ;
  g_nand_rw_speed=0 ;

#ifdef k_opt_password
  _lun_data(media) |= kbm_lun_media_lockable;
#endif



  // by default, it is thus.  However, we must check at run-time
  // whether or not to keep it such.  The removable bit is first used
  // checked on Inquiry processing
  _lun_data(media) &=~ kbm_lun_media_removable;
  _lun_data(device_type) = k_device_type_nand ;

  // we have to make sure we wait at least 1 ms before accessing the device,
  // but we don't have a timer running yet
  i=1000 ;
  while (i--) ;

  // try to identify the media configuration
  fmc_select_nand() ;
  if ( k_success != nand_identify_media_format() )
  {
    TRACE0(414, nand, 0, "failed to identify media format") ;
    return;
  }

// $$$ intercepting
  // util_trace_media() ;
  // util_trace_map_media() ;

  // read the boot block to see if out custom boot structure exists.
  nand_boot_seek() ;

#ifdef k_enable_write_caching


  // initialize the write head/tail cache
  map_write_cache_init() ;
#endif


  // safe erase the media here...  for utilitarian purposes
  // util_safe_erase_media() ;
  // util_trace_map_media();

/*
  for(g_addr_rd_phy_blk=0;g_addr_rd_phy_blk<8;g_addr_rd_phy_blk++)
  {
    util_trace_phy_block();
  }
*/

  // util_trace_log_media();
/*
  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;
  map_build_sector_map();
  util_test_copy_double_bit_ecc(33) ;
*/

  // store initial state of the wp bit.
  _nand_media_status = _mcu_register_rd(x_media_sts) ;
}

//------------------------------------------------------------------------------
void nand_dfa_inquiry(void) reentrant
{
  TRACE0(415, nand, 0, "nand_dfa_inquiry()") ;

  // check attribute bit... will be valid by this point
  if (g_dev_attr_lo&kbm_attr_lo_hd_as_rm)
  {
    TRACE0(416, nand, 0, "kbm_attr_lo_hd_as_rm bit set.  Reporting lun as Removable") ;
    _lun_data(media)|=kbm_lun_media_removable ;
  }
  else if (x_media_sts&kbm_media_sts_sm_wp )
  {
    TRACE0(417, nand, 0, "nand write protected.  Reporting lun as Removable") ;
    _lun_data(m