nand_int_media.c

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

/*============================================================================
  ____________________________________________________________________________
                                ______________________________________________
   SSSS  M   M          CCCC          Standard Microsystems Corporation
  S      MM MM   SSSS  C                    Austin Design Center
   SSS   M M M  S      C                 11000 N. Mopac Expressway
      S  M   M   SSS   C                Stonelake Bldg. 6, Suite 500
  SSSS   M   M      S   CCCC                Austin, Texas 78759
                SSSS            ______________________________________________
  ____________________________________________________________________________
  Copyright(C) 1999, Standard Microsystems Corporation
  All Rights Reserved.
  This program code listing is proprietary to SMSC and may not be copied,
  distributed, or used without a license to do so.  Such license may have
  Limited or Restricted Rights. Please refer to the license for further
  clarification.
  ____________________________________________________________________________
  Notice: The program contained in this listing is a proprietary trade
  secret of SMSC, Hauppauge, New York, and is copyrighted
  under the United States Copyright Act of 1976 as an unpublished work,
  pursuant to Section 104 and Section 408 of Title XVII of the United
  States code. Unauthorized copying, adaption, distribution, use, or
  display is prohibited by this law.
  ____________________________________________________________________________
  Use, duplication, or disclosure by the Government is subject to
  restrictions as set forth in subparagraph(c)(1)(ii) of the Rights
  in Technical Data and Computer Software clause at DFARS 52.227-7013.
  Contractor/Manufacturer is Standard Microsystems Corporation,
  80 Arkay Drive, Hauppauge, New York, 1178-8847.
  ____________________________________________________________________________
  ____________________________________________________________________________
  nand_2k_media.c - nand_2k flash media class implementation
  ____________________________________________________________________________
  comments tbd
  ____________________________________________________________________________
  Revision History
  Date      Who  Comment
  ________  ___  _____________________________________________________________
  11/05/02  cds  initial version 
  11/13/02  ds   defined more fns and added cope for chip select
  11/13/02  ds   added new fn nand_int_hw_bsy
  11/13/02  ds   modified fn nand_int_hw_bsy
  11/20/02  ds   - Added support for 211, in chip select.
                 - Fixed a bug in begin_quick_split where we allocate two physical blocks for the same logical
                 address.
  11/20/02  ds   The chip selects in 211 are inverted. Made the change.               
============================================================================*/
#define __nand_int_media_dot_c__
#include "project.h"

// provide vtable definition for 'nand_2k_media'
code _vtbl_defn(nand_int_media);

xdata uint8 _current_chip =0;
//------------------------------------------------------------------------------
//+-----------------------------------------------------------------------------
// Name:
//   nand_int_select_chip()
//
// Declaration:
//   void nand_int_select_chip(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void nand_int_select_chip(uint8 addr_segment) reentrant
{
  trace4(0, nand_int, 0, "nand_int_select_chip() - page:%d phy_blk:%d log:%d segment:%d", g_addr_page, g_addr_rd_phy_blk, g_addr_log_blk, addr_segment) ;
  _current_chip = addr_segment;
  switch (addr_segment)
  {
    #ifdef k_mcu_97242
    case 0:
      _mcu_register_wr(x_gpiob_out,kbm_gpio8);
      break;
    case 1:
      _mcu_register_wr(x_gpiob_out,kbm_gpio9);
      break;
    case 2:
      _mcu_register_wr(x_gpiob_out,kbm_gpio10);
      break;
    case 3:
      _mcu_register_wr(x_gpiob_out,kbm_gpio11);
      break;
    #endif
   #ifdef k_mcu_97211
    case 0:
      _mcu_register_wr(x_gpiob_out,~kbm_gpio12);
      break;
    case 1:
      _mcu_register_wr(x_gpiob_out,~kbm_gpio13);
      break;
    case 2:
      _mcu_register_wr(x_gpiob_out,~kbm_gpio14);
      break;
    case 3:
      _mcu_register_wr(x_gpiob_out,~kbm_gpio15);
      break;
    #endif
 
  }
  return; 
}


//------------------------------------------------------------------------------
//+-----------------------------------------------------------------------------
// Name:
//   nand_int_read_sector()
//
// Declaration:
//   t_result sm_media_read_sector(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_read_sector(void) reentrant
{
  TRACE4(444, nand, 0, "nand_int_read_sector() - zone:%d phy_blk:%d log:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_log_blk, g_addr_page) ;
  nand_int_select_chip(g_addr_segment);
  return(sm_media_read_sector());
}


//+-----------------------------------------------------------------------------
// Name:
//   nand_2k_write_sector()
//
// Declaration:
// t_result nand_2k_write_sector(uint8 *buf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_sector() reentrant
{
  trace4(0, n2k, 0, "nand_int_write_sector() - zone:%d log_blk:%d phy_blk:%d page:%d", g_addr_zone, g_addr_log_blk, g_addr_wr_phy_blk, g_addr_page) ;
  nand_int_select_chip(g_addr_segment);
  return(sm_media_write_sector());
}


//+-----------------------------------------------------------------------------
// Name:
//   nand_int_copy_sector()
//
// Declaration:
// t_result nand_int_copy_sector() reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_copy_sector() reentrant
{
  t_result result, result2;
  uint8 addr_segment;
  trace4(0, nand_int, 0, "nand_int_copy_sector() zone:%d SRC_BLK:%d DEST_BLK:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_wr_phy_blk, g_addr_page) ;

  result2=k_success;
  for (addr_segment=0;addr_segment<_media_data(segments_per_page);addr_segment++)
  {
    nand_int_select_chip(addr_segment);
    result=sm_media_copy_sector();

    // set result2 only if it's still "success"
    result2=(result2==k_success)?result:result2; 
  }

  trace1(0, nand_int, 0, "copy page result: %02x", result2);
  return(result2);
}

//+-----------------------------------------------------------------------------
// Name:
//   nand_2k_read_extra_data()
//
// Declaration:
//   TBD
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_read_extra_data(void) reentrant
{
  trace3(0, nand_int, 0, "nand_int_read_extra_data() zone:%d phy_blk:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_page) ;
  nand_int_select_chip(_media_data(segments_per_page)-1);
  return(sm_media_read_extra_data());
}


//+-----------------------------------------------------------------------------
// Name:
//   nand_int_write_extra_data()
//
// Declaration:
//   t_result nand_int_write_extra_data(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_extra_data(void) reentrant
{
  trace3(0, n2k, 0, "nand_2k_write_extra_data() zone:%d phy_blk:%d page:%d", g_addr_zone, g_addr_rd_phy_blk, g_addr_page) ;
  nand_int_select_chip(_media_data(segments_per_page)-1);
  return(sm_media_write_extra_data());
}


//+-----------------------------------------------------------------------------
// Name:
//   nand_int_erase_block()
//
// Declaration:
//   t_result nand_erase_block(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_erase_block(void) reentrant
{
  uint8 addr_segment;
//  uint8 save_page ;
  trace4(0, nand_int, 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) ;
  /*if ( (g_addr_wr_phy_blk == k_block_free) )
    return (k_media_err_illegal_lba );

  save_page = g_addr_page ;
  g_addr_page=0;
  nand_wr_va2pa() ;
  g_addr_page=save_page ;
  //needs to be updated for 4 chips
  _mcu_register_set_bits(x_gpiob_dir, kbm_gpio8 | kbm_gpio9);
  _mcu_register_set_bits(x_gpiob_out, kbm_gpio8 | kbm_gpio9);
  _sm_wr_cmd_begin(k_sm_erase1);
  _media_set_erase_addr() ; 
  _sm_set_wr_cmd(k_sm_erase2);

  for (addr_segment=0;addr_segment<_media_data(segments_per_page);addr_segment++)
  {
    nand_int_select_chip(addr_segment);
    if (sm_wait_rdy_with_timeout(k_sm_busy_erase_timeout))
    {
      trace0(0, sm_media, 0, "block erase failed.") ;
      nand_cmd_reset_device();
      return (k_error );
    }
  }
  _sm_hw_set_wr_standby();
  _sm_hw_set_rd_standby();
 */
  for (addr_segment=0;addr_segment<_media_data(segments_per_page);addr_segment++)
  {
    nand_int_select_chip(addr_segment);
    sm_media_erase_block();
  }

  return(k_success);
}

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

  trace2(0, cds, 0, "Checking busy status for chip %02x for media %02x",_current_chip,g_active_media);
  trace1(0, cds, 0, "gpioa_in %02x", _mcu_register_rd(x_gpioa_in));
  if ((_current_chip == 0) || (_current_chip == 4))
    result = ((!(_mcu_register_rd(x_gpioa_in) & kbm_gpio2))? k_true: k_false);

  if ((_current_chip == 1) || (_current_chip == 5))
    result = ((!(_mcu_register_rd(x_gpioa_in) & kbm_gpio4))? k_true: k_false);

  if ((_current_chip == 2) || (_current_chip == 6))
    result = ((!(gpio_rd() & kbm_gpio5))? k_true: k_false);

  if ((_current_chip == 3) || (_current_chip == 7))
    result = ((!(gpio_rd() & kbm_gpio7))? k_true: k_false);

  return(result);
}

//+-----------------------------------------------------------------------------
// Name:
//   n2k_write_begin_xfer
//
// Declaration:
//   void n2k_write_begin_xfer(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_begin_xfer() reentrant
{
  t_result result;
  uint16   max_split_size ;
  uint8 addr_segment = g_addr_segment;
  trace4(0, nand_int, 10, "nand_int_write_begin_xfer() - start:0x%04X%04X count:0x%04X%04X" , _hw(_fmc_get_start_lb_32()), _lw(_fmc_get_start_lb_32()), _hw(_fmc_get_lb_count_32()), _lw(_fmc_get_lb_count_32()));

  _lun_data(sensep) = &sense_write_error;

  // get virtual addr
  map_lba2addr_rd(_fmc_get_start_lb_32()) ;


  // copy block head
  result = map_write_begin( _fmc_get_start_lb_32() ) ;
  trace1(0, nand_int, 0, "g_addr_segment %02x",g_addr_segment);
  //copy page head
  if (g_addr_segment)   //are we in the middle of the page
  {
    for (addr_segment = 0; addr_segment < (g_addr_segment); addr_segment++)
    {
      nand_int_select_chip(addr_segment);
      result=sm_media_copy_sector();
      if (k_success!=result)
      {
        if (k_media_copy_error_src==result)
        {
          trace0(0, nand_int, 0, "read error detected.  continue copying") ;
        }
        else
        {
          trace0(0, nand_int, 0, "fatal error occured while copying.  aborting copy_block()") ;
          return(k_error);
        }
      }
    }
  }

  // precompute max split size
  max_split_size = (_media_data(pages_per_block)-g_addr_page)*_media_data(segments_per_page)-g_addr_segment ;

  if (!g_addr_page)
  {
    _lun_data(max_lb_per_split) = _min( max_split_size, _fmc_get_lb_count_32());
    trace5(0, nand_int, 10, "-----write begin xfer - zone:%d phy:%d log:%d page:%d count:%d - first in block", g_addr_zone, g_addr_wr_phy_blk, g_addr_log_blk, g_addr_page, _lun_data(max_lb_per_split) );
  }
  else
  {
    _lun_data(max_lb_per_split) = _min( max_split_size, _fmc_get_lb_count_32());
    trace5(0, nand_int, 10, "-----write begin xfer - zone:%d phy:%d log:%d page:%d count:%d", g_addr_zone, g_addr_wr_phy_blk, g_addr_log_blk, g_addr_page, _lun_data(max_lb_per_split));
  }

  // burst size needs to be 1, because the sm controller can't
  // handle more than 512 bytes out at a time.
  _lun_data(max_lb_per_burst) = 1;
  return(result );
}

//+-----------------------------------------------------------------------------
// Name:
//   nand_int_write_end_xfer
//
// Declaration:
//   void nand_int_write_end_xfer(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_end_xfer() reentrant
{

  t_result result ;
  uint8 addr_segment = g_addr_segment;
  trace0(0, nand_int, 1, "nand_int_write_end_xfer()") ;

  if (k_success != _fmc_get_result())
    return(k_error);

  _mcu_register_clr_bits(x_fmc_ctl, kbm_fmc_ctl_auto_trans);
  trace0(0, nand_int, 0, "auto-transfer bit ==> OFF");

  result=map_write_flush() ;
  if (_media_data(options)&(kbm_media_data_opt_write_cache|kbm_media_data_opt_erase_cache))
  {