sm.c

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

//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_dbg_dump_redt_data() reentrant
{
  uint8 i ;

  for (i=0; i<16;i++)
  {
    trace2(0, sm, 0, "x_sm_redt_data[%d]:%02x", i, (uint16) x_sm_redt_data[i]) ;
  }
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_set_rd_cmd()
//
// Declaration:
//   void sm_set_rd_cmd(uint8 cmd) reentrant
//
// Purpose:
//   set up the media for issuing read command
//   (using write protection signal to prevent accidental writes)
//
// Arguments:
//   cmd  - command to be issued.  should be one of the following
//          constants: k_sm_read, k_sm_read_redt, k_sm_read2, k_sm_reset_chip
//          k_sm_read_status or k_sm_read_id
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_set_rd_cmd(uint8 cmd) reentrant
{
  trace1(0, sm, 50, "sm_set_rd_cmd(%02x)", cmd) ;
  _sm_hw_set_rd_cmd();
  _sm_data_wr(cmd);
  _sm_hw_set_rd_data(g_nand_rw_speed);
}



void sm_set_wr_cmd(uint8 cmd) reentrant
{
  trace1(0, sm, 50, "sm_set_wr_cmd(%02x)", cmd) ;
  _sm_hw_set_wr_cmd() ;
  _sm_data_wr(cmd);
  _sm_hw_set_wr_data(g_nand_rw_speed);
}




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

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

//+-----------------------------------------------------------------------------
// Name:
//   bit_count8()
//
// Declaration:
//   t_result bit_count8(void) reentrant ;
//
// Purpose:
//   Count # of bits in a 8-bit value
//
// Arguments:
//   val  - 8-bit value in which to count bits
//
// Return:
//   0-8, depending on the number of bits set in 'val'
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
uint8 bit_count8(uint8 val) reentrant
{
  uint8 cnt=0;
  while (val)
  {
    cnt+=(uint8)(val &0x01);
    val >>=1 ;
  }
  return (cnt);
}

//+-----------------------------------------------------------------------------
// Name:
//   TBD
//
// Declaration:
//   TBD
//
// Purpose:
//   Count # of bits in a 16-bit value
//
// Arguments:
//   val  - 16-bit value in which to count bits
//
// Return:
//   0-16, depending on the number of bits set in 'val'
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
uint8 bit_count16(uint16 val) reentrant
{
  uint8 cnt=0;
  while (val)
  {
    cnt+= (uint8) (val&0x01);
    val>>=1;
  }
  return (cnt);
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_wait_rdy_with_timeout()
//
// Declaration:
//   t_result sm_wait_rdy_with_timeout(uint16 ticks) reentrant
//
// Purpose:
//
// Arguments:
//   none
//
// Return:
//
// Notes:
//   currently, not a dfa
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result sm_wait_rdy_with_timeout(uint16 ticks) reentrant
{
  t_sync sync ;

  trace1(0, sm, 0, "g_active_media %02x ", g_active_media);
  thread_set_timer( ticks ) ;
  sync = kbm_sync_none ;
  while ( !(sync & kbm_sync_timer))
  {
    // $$$ cds -> should patch in the usbrst and abort syncs after sm debug
    sync = thread_got_sync(kbm_sync_timer) ;
    _thread_clr_sync(sync) ;
    if (sync & kbm_sync_usbrst)
    {
      trace0(0, sm, 1, "sm_wait_rdy_with_timeout() - error: kbm_sync_usbrst");
      return (k_usbreset);
    }
    if (sync & kbm_sync_abort)
    {
      trace0(0, sm, 1, "sm_wait_rdy_with_timeout() - error: kbm_sync_abort");
      return (k_aborted);
    }
    if (sync & kbm_sync_timer)
    {
      trace0(0, sm, 1, "sm_wait_rdy_with_timeout() - timed out");
      return (k_timeout);
    }

    // the actual unique condition
    if (g_active_media == k_ix_media_nand_int)
    {
      if (!nand_int_hw_bsy())
      {
        return (k_success);
      }
    }
    else
    {
      if (!_sm_hw_bsy() )
      {
        return (k_success);
      }
    }
  }

  trace0(0, sm, 0, "sm_wait_rdy_with_timeout() - should not get here!!!") ;
  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
//------------------------------------------------------------------------------
void sm_reset_device(void) reentrant
{
  // reset the chip
  trace0(0, sm, 0, "sm_reset_device()") ;
  _sm_rd_cmd_begin(k_sm_reset_chip) ;
  sm_wait_rdy_with_timeout(k_sm_busy_reset_timeout) ;
  _sm_hw_set_rd_standby();
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_read_id()
//
// Declaration:
//   uint8 sm_read_id(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
xdata uint8 nand_id_maker ;
xdata uint8 nand_id_device ;
xdata uint8 nand_id_3;
xdata uint8 nand_id_4;
xdata uint8 nand_id_5;
xdata uint8 nand_id_ex_1 ;

uint8 sm_read_id(void) reentrant
{
  uint8 dummy ;
  uint8 i ;

  nand_cmd_read_id();
  nand_id_maker  = _sm_data_rd() ;
  nand_id_device = _sm_data_rd() ;
  nand_id_3 = _sm_data_rd() ;
  nand_id_4 = _sm_data_rd() ;
  nand_id_5 = _sm_data_rd() ;

  trace1(0, sm, 0, "nand maker :%02X", nand_id_maker);
  trace1(0, sm, 0, "nand device:%02X", nand_id_device) ;
  trace1(0, sm, 0, "nand id 3  :%02X", nand_id_3);
  trace1(0, sm, 0, "nand id 4  :%02X", nand_id_4);
  trace1(0, sm, 0, "nand id 5  :%02X", nand_id_5);

  // turn off chip enable
  _sm_hw_set_rd_standby();

  if (0xa5==nand_id_3)
  {
    trace0(0, sm, 0, "card has unique Smart Media ID assignment") ;
  }

  // auto detect advanced card capabilities
  nand_id_ex_1=0 ;
  if (nand_id_4 == 0xc0)
  {
    nand_cmd_read_id_ex() ;
    nand_id_ex_1=_sm_data_rd() ;
    for (i=1;i<8;i++)
    {
      dummy = _sm_data_rd() ;
      trace2(0, sm, 0, "read_id_ex data[%d]:%02x", i, dummy) ;
    }
  }
  // turn off chip enable
  _sm_hw_set_rd_standby();
  return (nand_id_device );
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_identify_media_format()
//
// Declaration:
//   t_result sm_media_erase_all(void) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result sm_identify_media_format(void) reentrant
{
  uint8 idcode ;

  idcode = sm_read_id() ;

  _media_data(segments_per_page)=1;
  _media_data(options)=kbm_media_data_opt_none;
  switch (idcode)
  {
    /* 8Mbit (1M) NAND */
    case 0x6E:
    case 0xE8:
    case 0xEC:
      trace0(0, sm, 0, "1 MB Flash SmartMedia Device. num_zones:1, phy_blks_per_zone:256, log_blks_per_zone:250, pages_per_blk:16 sectors_per_page:0.5") ;
      _media_data(num_zones)                    =1;
      _media_data(physical_blocks_per_zone)     =256;
      _media_data(logical_blocks_per_zone)      =250;
      _media_data(logical_blocks_per_boot_zone) =1000;
      _media_data(pages_per_block)              =8;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      x_media_sts |= kbm_media_sts_sm_256_page ;
      break;

      /* 16Mbit (2M) NAND */
    case 0x64:
    case 0xEA:
    case 0xF1:          // $$$$ hack
      trace0(0, sm, 0, "2 MB Flash SmartMedia Device. num_zones:1, phy_blks_per_zone:512, log_blks_per_zone:500, pages_per_blk:16 sectors_per_page:0.5") ;
      _media_data(num_zones)                    =1;
      _media_data(physical_blocks_per_zone)     =512;
      _media_data(logical_blocks_per_zone)      =500;
      _media_data(logical_blocks_per_boot_zone) =1000;
      _media_data(pages_per_block)              =8;
      x_media_sts |= kbm_media_sts_sm_256_page ;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      break;

      /* 32Mbit (4M) NAND */
    case 0x6B:
    case 0xE3:
    case 0xE5:
      trace0(0, sm, 0, "4 MB Flash SmartMedia Device. num_zones:1, phy_blks_per_zone:512, log_blks_per_zone:500, pages_per_blk:16 sectors_per_page:1") ;
      _media_data(num_zones)                    =1;
      _media_data(physical_blocks_per_zone)     =512;
      _media_data(logical_blocks_per_zone)      =500;
      _media_data(logical_blocks_per_boot_zone) =500;
      _media_data(pages_per_block)              =16;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      break;

      /* 64Mbit (8M) NAND */
    case 0xE6:
      trace0(0, sm, 0, "8 MB Flash SmartMedia Device. num_zones:1, phy_blks_per_zone:1024, log_blks_per_zone:1000, pages_per_blk:16 sectors_per_page:1") ;
      _media_data(num_zones)                    =1;