www.pudn.com > SMSC USB2.0.zip > nand_int_media.c
/*============================================================================
____________________________________________________________________________
______________________________________________
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))
{
_lun_data(media)|=kbm_lun_media_process_idle;
}
_sm_hw_set_wr_standby() ;
_sm_hw_set_rd_standby() ;
if (k_success == result)
_lun_data(sensep) = &sense_none;
return(result );
}
//+-----------------------------------------------------------------------------
// Name:
// nand_int_write_begin_split
//
// Declaration:
// t_result nand_int_write_begin_split(void);
//
// Purpose:
// Issue the write command to the smart media device.
//
// Arguments:
// None.
//
// Return:
// A t_result indicating:
// k_success - command completed.
//
// Notes:
// This is a FUNCTION, not a DFA.
// Do not yeild, or run a DFA, from within this callback.
//
// Since:
// fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_begin_quick_split() reentrant
{
uint8 zone_before ;
t_result result;
t_sync sync;
uint8 cnt;
trace0(0, nand_int, 1, "sm_write_begin_split()");
trace1(0, nand_int, 0, "g_addr_rd_phy_blk: %d", g_addr_rd_phy_blk) ;
zone_before = g_addr_zone ;
// if a new physical block, tell the mapper to go git us one.
if (k_success != map_lba2addr_rd(_fmc_get_start_lb_32()))
return(k_error);
if (g_addr_zone != zone_before)
{
// we've crossed a boundry on a split, do a reset
trace0(0, nand_int, 0, "zone-change detected.") ;
nand_int_select_chip(_media_data(segments_per_page)-1);
_sm_set_rd_cmd(k_sm_reset_chip);
sm_wait_rdy_with_timeout(k_sm_busy_reset_timeout);
}
if(g_addr_wr_phy_blk == k_block_free)
{
if (k_success != map_alloc_wr_blk())
return(k_error);
}
// convert virtual address zone/block/sector into page/offsets
nand_rd_va2pa() ;
nand_wr_va2pa() ;
// write the count registers which won't change
_mcu_register_wr(x_fmc_cnt3, 0);
_mcu_register_wr(x_fmc_cnt2, 0);
_mcu_register_wr(x_fmc_cnt0, 0);
result = k_success;
// do max of 1 splits worth of bursts
cnt=(uint8) _fmc_get_lb_count_32();
while (cnt)
{
trace1(0, nand_int, 0, "cnt %02x",cnt);
//choose the target chip
nand_int_select_chip(g_addr_segment);
//check to see if the chip is busy
if ( nand_int_hw_bsy())
{
//then wait for it to be done
result = sm_wait_rdy_with_timeout(k_sm_busy_programming_timeout);
if (result != k_success)
{
//something is seriously wrong
trace0(0, cds, 0, "Fatal error aborted waiting for the chip to get ready!!");
return(result);
}
}
//------------------------------------------------------------------------------
// check status... not necessary for first write, but coding is simpler to just always do it.
if (k_success != nand_cmd_check_status_new())
{
trace0(0, cds, 0, "sm_write_end_burst - write fault") ;
return(k_error);
}
//------------------------------------------------------------------------------
// start a single burst
trace4(0, sm, 0, "+sm_write_begin_burst() - zone:%d phy:%d log:%d page:%d", g_addr_zone, g_addr_wr_phy_blk, g_addr_log_blk, g_addr_page) ;
_sm_set_wr_cmd(k_sm_write_data);
_media_set_write_addr() ;
_mcu_register_set_bits(sm_mode_ctl, kbm_sm_mode_ecc_blk_xfer_en);
_sm_hw_ecc_wr_start() ;
_mcu_register_wr(x_smc_stat, kbm_smc_stat_rdy);
//------------------------------------------------------------------------------
// start the blk xfer
// clear blk_xfer_complete irq.
_mcu_register_wr(x_isr0, kbm_isr0_blk_xfer_complete);
_mcu_register_wr(x_fmc_cnt1, 0x02);
_mcu_register_set_bits(x_fmc_ctl, kbm_fmc_ctl_blk_xfer_en);
//------------------------------------------------------------------------------
// do calculations while data is moving (or waiting to move)
cnt--;
g_addr_segment=(g_addr_segment+1)%_media_data(segments_per_page);
if (!g_addr_segment)
{
trace0(0, nand_int, 0, "last burst in the page" ) ;
g_addr_page++;
nand_incr_addr() ;
}
//------------------------------------------------------------------------------
// wait for data to finish moving
thread_set_timer(g_fmc_timeout);
do
{
sync = _thread_got_sync(kbm_sync_abort |kbm_sync_usbrst |kbm_sync_timer);
_thread_clr_sync(sync);
if (sync & kbm_sync_usbrst)
{
trace0(0, cds, 1, "optimized fmc_wait_blk_irq_with_timeout() - error: kbm_sync_usbrst");
result = k_usbreset;
break;
}
if (sync & kbm_sync_abort)
{
trace0(0, cds, 1, "optimized fmc_wait_blk_irq_with_timeout() - error: kbm_sync_abort");
result = k_aborted;
break;
}
if (sync & kbm_sync_timer)
{
trace0(0, cds, 1, "optimized fmc_wait_blk_irq_with_timeout() - error: timeout awaiting irq");
result = k_timeout;
break;
}
// AAA: added this to poll instead of taking the interrupt
// cds: added isr bit fmc_irq to break out of loop for fmc error (ecc or otherwise) detection
} while (!(_mcu_register_rd(x_isr0) & (kbm_isr0_blk_xfer_complete) ));
_sm_hw_ecc_wr_stop() ;
sm_mode_ctl &= ~kbm_sm_mode_ecc_blk_xfer_en;
if (k_success!=result)
{
trace0(0, cds, 0, "optimized interleaved write split error in xfer. aborting") ;
return (result);
}
// issue command to program the flash, then loop to next chip
trace0(0, sm, 0, "cmd: write") ;
_sm_set_wr_cmd(k_sm_write);
}
//------------------------------------------------------------------------------
// do one final pass through waiting for write to finally finish on all chips
for (cnt=0;cnt<_media_data(segments_per_page);cnt++)
{
nand_int_select_chip(cnt);
if ( nand_int_hw_bsy())
{
//then wait for it to be done
result = sm_wait_rdy_with_timeout(k_sm_busy_programming_timeout);
if (result != k_success)
{
//something is seriously wrong
trace0(0, cds, 0, "Fatal error aborted waiting for the chip to get ready!!");
return(result);
}
}
if (k_success != nand_cmd_check_status_new())
{
trace0(0, cds, 0, "sm_write_end_burst - write fault") ;
return(k_error );
}
}
g_start_lb_this_xfer.u32 += g_n_lb_this_split.u32;
g_n_lb_this_xfer.u32 -= g_n_lb_this_split.u32;
_mscbot_decr_residue( (g_n_lb_this_split.u32*512L) );
g_n_lb_this_split.u32 = 0;
return(k_success);
}
//+-----------------------------------------------------------------------------
// Name:
// nand_int_write_begin_split
//
// Declaration:
// t_result nand_int_write_begin_split(void);
//
// Purpose:
// Issue the write command to the smart media device.
//
// Arguments:
// None.
//
// Return:
// A t_result indicating:
// k_success - command completed.
//
// Notes:
// This is a FUNCTION, not a DFA.
// Do not yeild, or run a DFA, from within this callback.
//
// Since:
// fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_begin_split() reentrant
{
#ifdef Dominic
uint8 zone_before ;
uint8 addr_segment;
trace0(0, nand_int, 1, "sm_write_begin_split()");
trace1(0, nand_int, 0, "g_addr_rd_phy_blk: %d", g_addr_rd_phy_blk) ;
zone_before = g_addr_zone ;
// if a new physical block, tell the mapper to go git us one.
if (k_success != map_lba2addr_rd(_fmc_get_start_lb_32()))
return(k_error);
if (g_addr_zone != zone_before)
{
// we've crossed a boundry on a split, do a reset
trace0(0, nand_int, 0, "zone-change detected.") ;
nand_int_select_chip(_media_data(segments_per_page)-1);
sm_set_write_mode_page_data();
nand_int_select_chip(g_addr_segment);
}
if (!g_addr_page)
{
if (k_success != map_alloc_wr_blk())
return(k_error);
}
// convert virtual address zone/block/sector into page/offsets
nand_rd_va2pa() ;
nand_wr_va2pa() ;
trace0(0, sm, 0, "ready to begin writing sectors") ;
#endif
return(k_success);
}
//+-----------------------------------------------------------------------------
//------------------------------------------------------------------------------
t_result nand_int_write_end_split(void) reentrant
{
uint8 addr_segment = g_addr_segment;
t_result result;
trace0(0, cds, 0, "nand_int_write_end_split()") ;
trace2(0, nand_int, 0, "split ended on to page %d segment %d", g_addr_page, g_addr_segment) ;
if ( g_addr_segment )
{
_mcu_register_clr_bits(x_fmc_ctl, kbm_fmc_ctl_auto_trans);
trace0(0, nand_int, 0, "auto-transfer bit ==> OFF");
//copy page tail
for (; addr_segment < _media_data(segments_per_page); 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);
}
}
}
g_addr_page++;
g_addr_segment=0;
nand_incr_addr() ;
}
return(sm_write_end_split() );
}
//+-----------------------------------------------------------------------------
// Name:
// sm_write_begin_burst
//
// Declaration:
// t_result sm_write_begin_burst(void);
//
// Purpose:
// Issue the write command to the smart media device.
//
// Arguments:
// None.
//
// Return:
// A t_result indicating:
// k_success - command completed.
//
// Notes:
// This is a FUNCTION, not a DFA.
// Do not yeild, or run a DFA, from within this callback.
//
// Since:
// fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_begin_burst() reentrant
{
#ifdef Dominic
t_result result;
trace5(0, nand_int, 0, "nand_int_write_begin_burst() - zone:%d log:%d-phy:%d page:%d seg:%d", g_addr_zone, g_addr_log_blk, g_addr_wr_phy_blk, g_addr_page, g_addr_segment) ;
trace1(0, nand_int, 0, " - n_lbs_this_xfer:%d", g_n_lb_this_xfer.u32) ;
//choose the next chip
nand_int_select_chip(g_addr_segment);
//check to see if the chip is busy
if ( nand_int_hw_bsy())
{
//then wait for it to be done
result = sm_wait_rdy_with_timeout(k_sm_busy_programming_timeout);
if (result != k_success)
{
//something is seriously wrong
trace0(0, nand_int, 0, "Fatal error aborted waiting for the chip to get ready!!");
return(result);
}
//check to see if there is a status failure
if (k_success != nand_cmd_check_status())
{
trace0(0, sm, 0, "sm_write_end_burst - write fault") ;
g_addr_page-- ;
return(k_error );
}
}
//check to see if there is a status failure
if (k_success != nand_cmd_check_status())
{
trace0(0, sm, 0, "sm_write_end_burst - write fault") ;
g_addr_page-- ;
return(k_error );
}
// _mcu_register_set_bits(sm_mode_ctl,kbm_sm_mode_ecc_blk_xfer_en) ;
// _sm_hw_ecc_wr_start() ;
trace0(0, nand_int, 0, "bursting") ;
#endif
return(sm_write_begin_burst());
}
//+-----------------------------------------------------------------------------
// Name:
// sm_write_end_burst
//
// Declaration:
// t_result sm_write_end_burst(void);
//
// Purpose:
// TBD
//
// Arguments:
// None.
//
// Return:
// A t_result indicating:
// k_success - command completed.
//
// Notes:
// This is a FUNCTION, not a DFA.
// Do not yeild, or run a DFA, from within this callback.
//
// Since:
// fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_write_end_burst(void) reentrant
{
#ifdef Dominic
trace0(0, sm, 0, "nand_int_write_end_burst()") ;
_sm_hw_ecc_wr_stop() ;
sm_mode_ctl &= ~kbm_sm_mode_ecc_blk_xfer_en;
trace0(0, sm, 0, "ecc_en off") ;
//x_smc_stat = kbm_smc_stat_rdy ;
trace0(0, sm, 0, "cmd: write") ;
_sm_set_wr_cmd(k_sm_write);
g_addr_segment++ ;
if ( g_addr_segment==_media_data(segments_per_page) )
{
trace0(0, nand_int, 0, "last burst in the page" ) ;
g_addr_page++;
g_addr_segment=0;
nand_incr_addr() ;
}
#endif
return(k_success );
}
//+-----------------------------------------------------------------------------
// Name:
// nand_int_read_end_burst
//
// Declaration:
// t_result nand_int_read_end_burst(void);
//
// Purpose:
// TBD
//
// Arguments:
// None.
//
// Return:
// A t_result indicating:
// k_success - command completed.
//
// Notes:
// This is a FUNCTION, not a DFA.
// Do not yeild, or run a DFA, from within this callback.
//
// Since:
// fmc-1.0
//------------------------------------------------------------------------------
t_result nand_int_read_end_burst(void) reentrant
{
t_result result;
trace0(0, nand_int, 0, "nand_int_read_end_burst()") ;
//just check if the chip is done.., should be at this point
if (k_success != sm_wait_rdy_with_timeout(k_sm_busy_read_timeout))
{
TRACE0(445, nand, 0, "error waiting for data") ;
nand_cmd_reset_device();
return(k_error );
}
result = sm_read_end_burst();
g_addr_segment++ ;
if ( g_addr_segment==_media_data(segments_per_page) )
{
g_addr_page++;
g_addr_segment=0;
nand_incr_addr() ;
}
//select the appropriate chip
nand_int_select_chip(g_addr_segment);
return(result);
}