sm.c

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

      _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)              =16;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      break;

      /*128Mbit (16M)NAND */
    case 0x73:
      trace0(0, sm, 0, "16 MB Flash SmartMedia Device. num_zones:1, phy_blks_per_zone:1024, log_blks_per_zone:1000, pages_per_blk:32 sectors_per_page:1") ;
      _media_data(num_zones)                    =1;
      _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)              =32;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      break;

      /*256Mbit (32M)NAND */
    case 0x75:
      trace0(0, sm, 0, "32 MB Flash SmartMedia Device. num_zones:2, phy_blks_per_zone:1024, log_blks_per_zone:1000, pages_per_blk:32 sectors_per_page:1") ;
      _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)              =32;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;
      _lun_data(media) &= ~kbm_sm_media_addr_4cyc ;  // 3 cycle addressing
      break;

      /*512Mbit (64M)NAND */
    case 0x76:
      trace0(0, sm, 0, "64 MB Flash SmartMedia Device. num_zones:4, phy_blks_per_zone:1024, log_blks_per_zone:1000, pages_per_blk:32 sectors_per_page:1") ;
      _media_data(num_zones)                   =4;
      _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)             =32;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;
      _lun_data(media) |= kbm_sm_media_addr_4cyc ;  // 4 cycle addressing
      break;

      /* 1Gbit(128M)NAND */
    case 0x79:
      trace0(0, sm, 0, "128 MB Flash SmartMedia Device. num_zones:8, phy_blks_per_zone:1024, log_blks_per_zone:1000, pages_per_blk:32 sectors_per_page:1") ;
      _media_data(num_zones)                   =8;
      _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)             =32;
      x_media_sts &= ~kbm_media_sts_sm_256_page ;  // 512+16
      _lun_data(media) |= kbm_sm_media_addr_4cyc ;  // 4 cycle addressing
      break;
    default:
      trace1(0, sm, 0, "Illegal Device ID Code: %02x", idcode) ;
      return (k_error );
  }

  // clear the rw speed to set sm-compatible mode... this needs to move into some sort of
  // per-instance variable perhaps in _media_data() or something...
  g_nand_rw_speed=0 ;

  // check for media write protection
  trace1(0, sm, 0, "media write protected: %c", ((x_media_sts & kbm_media_sts_sm_wp)?'y':'n')) ;
  // TRACE1(225, sm, 0, "x_media_sts: %02x", x_media_sts) ;

  // write protect if
  //  - wp bit is detected
  //  - 256+8 media is inserted
  if (_mcu_register_rd(x_media_sts)&(kbm_media_sts_sm_wp|kbm_media_sts_sm_256_page))
    _lun_data(media) |= kbm_lun_media_wrprot ;
  else
    _lun_data(media) &= ~kbm_lun_media_wrprot ;

  return (k_success );
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_soft_reset()
//
// Declaration:
//   void sm_soft_reset(void) reentrant
//
// Purpose:
//   send a software reset to the smart media card
//
// Arguments:
//   none
//
// Return:
//   none
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_soft_reset(void) reentrant
{
  trace0(0, sm, 0, "sm_soft_reset()") ;
  _sm_rd_cmd_begin(k_sm_reset_chip) ;
  sm_wait_rdy_with_timeout(k_sm_busy_reset_timeout);
  _sm_rd_cmd_begin(k_sm_read) ;
  sm_wait_rdy_with_timeout(k_sm_busy_read_timeout);
  _sm_hw_set_rd_standby();
}




//+-----------------------------------------------------------------------------
// Name:
//   sm_pio_rd_buf()
//
// Declaration:
//   void sm_pio_rd_buf(uint8 *databuf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_pio_rd_buf(uint8 *databuf) reentrant
{
  uint16 i;
  i=(x_media_sts&kbm_media_sts_sm_256_page)?0x100:0x200 ;
  while (i--)
    *databuf++ =_sm_data_rd();
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_pio_wr_buf()
//
// Declaration:
//   void sm_pio_wr_buf(uint8 *databuf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_pio_wr_buf(uint8 *databuf) reentrant ;
void sm_pio_wr_buf(uint8 *databuf) reentrant
{
  uint16 i;
  i=(x_media_sts&kbm_media_sts_sm_256_page)?0x100:0x200 ;
  while (i--)
    _sm_data_wr(*databuf++) ;
}



code uint8 _cis_signature[]={ 0x01,0x03,0xD9,0x01,0xFF,0x18,0x02,0xDF,0x01,0x20};
//+-----------------------------------------------------------------------------
// Name:
//   sm_validate_cis()
//
// Declaration:
//   t_result sm_validate_cis(uint8 *buf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
// extern void fmc_dbg_dump_sector(uint8* sector) reentrant ;
t_result sm_validate_cis(uint8 *buf) reentrant
{
#if (k_log_lun_sm < k_max_log_lun)
  t_result result ;
  trace0(0, sm, 0, "+sm_validate_cis()") ;

  if ( 0 == ((x_sm_redt_data[k_ix_redt_ecc1_0]^x_eccbuf[0])|
             (x_sm_redt_data[k_ix_redt_ecc1_1]^x_eccbuf[1])|
             (x_sm_redt_data[k_ix_redt_ecc1_2]^x_eccbuf[2])))
  {
    trace0(0, sm, 0, "no ecc issues... check to see if the data is there") ;
    result = (memcmp((uint8*)buf, (uint8*)_cis_signature, 10)?k_error:k_success) ;
    if (k_success != result)
    {
      trace0(0, sm, 0, "error reading sector!") ;
    }
    else
    {
      return (result );
    }
  }
  else
  {
    trace0(0, sm, 0, "redundant ecc data does not match sector ecc.  compute ecc data from data buffer");
    if (k_success == ecc_sw_correct(buf,x_sm_redt_data+0x0D,x_eccbuf))
    {
      trace0(0, sm, 0, "ecc computation successful.  check cis signature.") ;
      return( memcmp((char *)buf,(char *)_cis_signature,10)?k_error : k_success );
    }
  }

  // check backup cis
  buf+=0x100;
  if ( 0 == ((x_sm_redt_data[k_ix_redt_ecc2_0]^x_eccbuf[3])|
             (x_sm_redt_data[k_ix_redt_ecc2_1]^x_eccbuf[4])|
             (x_sm_redt_data[k_ix_redt_ecc2_2]^x_eccbuf[5])))
    return(memcmp((uint8*)buf,(uint8*)_cis_signature,10)?k_error:k_success);

  trace0(0, sm, 0, "ecc error(s) detected.  tring to correct the data") ;
  if (k_success == ecc_sw_correct(buf,x_sm_redt_data+0x08,x_eccbuf+0x03))
  {
    trace0(0, sm, 0, "SoftwareECC worked.  compare cis tag") ;
    return(memcmp((uint8 *)buf,(uint8*)_cis_signature,10)?k_error:k_success);
  }
  trace0(0, sm, 0, "cis data invalid") ;
#else
  trace0(0, sm, 0, "+sm_validate_cis() - software validation disabled") ;
  buf=buf ;             // keep compiler quiet
#endif


  return (k_error );
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_redt_is_data_valid()
//
// Declaration:
//   t_result sm_redt_is_data_valid(void) reentrant
//
// Purpose:
//   TBD
//
// Arguments:
//   TBD
//
// Return:
//   TBD
//
// Notes:
//   TBD
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_synch_hw_buff_to_redt_buf(void) reentrant
{
  trace0(0, sm_media, 0, "synching smc redt buf w/ x_sm_redt_data") ;

  XBYTE[0x3660]=0xFF;
  XBYTE[0x3661]=0xFF;
  XBYTE[0x3662]=0xFF;
  XBYTE[0x3663]=0xFF;
  XBYTE[0x3664]=x_sm_redt_data[k_ix_redt_data_status];
  XBYTE[0x3665]=x_sm_redt_data[k_ix_redt_block_status];
  XBYTE[0x3666]=x_sm_redt_data[k_ix_redt_lba1_hi] ;
  XBYTE[0x3667]=x_sm_redt_data[k_ix_redt_lba1_lo] ;
  XBYTE[0x3668]=x_sm_redt_data[k_ix_redt_lba2_hi] ;
  XBYTE[0x3669]=x_sm_redt_data[k_ix_redt_lba2_lo] ;
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_set_write_mode_extra_data()
//
// Declaration:
// t_result sm_set_write_mode_extra_data(uint8 *buf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_set_write_mode_extra_data(void) reentrant
{
  trace0(0, sm, 0, "sm_set_write_mode_extra_data()") ;
  x_smc_stat = kbm_smc_stat_rdy ;
  _sm_set_rd_cmd(k_sm_reset_chip);
  sm_wait_rdy_with_timeout(k_sm_busy_reset_timeout);
  _sm_set_rd_cmd(k_sm_read_redt);
  sm_wait_rdy_with_timeout(k_sm_busy_read_timeout);
  _sm_hw_set_rd_standby();
}

//+-----------------------------------------------------------------------------
// Name:
//   sm_write_redt_mode()
//
// Declaration:
// t_result sm_write_redt_mode(uint8 *buf) reentrant
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
void sm_set_write_mode_page_data(void) reentrant
{
  trace0(0, sm, 0, "sm_set_write_mode_page_data()") ;
  x_smc_stat = kbm_smc_stat_rdy ;
  _sm_set_rd_cmd(k_sm_reset_chip);
  sm_wait_rdy_with_timeout(k_sm_busy_reset_timeout);
  _sm_set_rd_cmd(k_sm_read);
  sm_wait_rdy_with_timeout(k_sm_busy_read_timeout);
  _sm_hw_set_rd_standby();
}


//+-----------------------------------------------------------------------------
// Name:
//   sm_media_check_format()
//
// Declaration:
//   t_result sm_media_check_format(void) reentrant ;
//
// Purpose:
//
// Arguments:
//
// Return:
//
// Notes:
//   this is a function
//
// Since:
//   fmc-1.0
//------------------------------------------------------------------------------
t_result sm_media_check_format(void) reentrant
{
  trace0(0, sm, 0, "sm_media_check_format()") ;

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

  // set to unknown, until we go through this process
  _lun_data(media) |= kbm_lun_media_unknown ;
  if ( k_success != sm_identify_media_format() )
    return (k_error);

#ifdef k_sm_repair_card
  trace0(0, sm, 0, "Forcing the repair of a card") ;
  util_blank_smart_media_card() ;

  if ( k_success != sm_media_seek_cis() )
  {
    trace0(0, sm, 0, "could not find card-info sector... repairing boot block") ;
    g_addr_zone=0;
    for (g_addr_rd_phy_blk=0;g_addr_rd_phy_blk<8;g_addr_rd_phy_blk++)
    {
      util_trace_phy_block();
    }

    util_blank_smart_media_card() ;

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

    if ( k_success != sm_media_seek_cis() )
    {
      trace0(0, sm, 0, "*** unable to repair boot block") ;
      return (k_error);
    }
  }
#else
  if ( k_success != sm_media_seek_cis())
    return (k_error);
#endif