nf_mngt.h File Reference

#include "config.h"
#include "conf_nf.h"
#include "nf.h"
#include "modules/control_access/ctrl_status.h"
#include "nf_drv.h"

Include dependency graph for nf_mngt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Cache_lut
struct	Cache_fbb
Defines
#define	NF_BLK_RCV_NO_RECOVERY   0xA5
#define	NF_BLK_RCV_PENDING_RECOVERY   0x5A
#define	NF_LOW_N_FREE_THRESHOLD   5
#define	NF_PAGE_BUFFER_SIZE   2048
#define	NF_FULL_PAGE_BUFFER_SIZE   ( (NF_PAGE_BUFFER_SIZE) + (NF_PAGE_BUFFER_SIZE)/32 )
#define	NF_SHIFT_SUBLUT_PHYS   ( (G_SHIFT_PAGE_BYTE)-1 )
#define	NF_SUBLUT_SIZE   ( 1L<<(NF_SHIFT_SUBLUT_PHYS) )
#define	NF_N_MAX_BLOCKS   (8*1024)
#define	N_SUBLUT   (NF_N_DEVICES*NF_N_MAX_BLOCKS/(512/2))
#define	S_SHIFT_SECTOR_BYTE   s_shift_sector_byte
#define	S_SHIFT_LOG_PAGE_SECTOR   s_shift_log_page_sector
#define	S_SHIFT_LOG_BLOCK_SECTOR   s_shift_log_block_sector
#define	S_MNGT_DEV   ((NF_N_DEVICES)-1)
#define	Nf_check_fbb(x)   nf_check_fbb(x)
#define	Nf_check_lut()   nf_check_lut()
#define	CACHE_LUT_SIZE   (NF_CACHE_LUT_LOG_SZ*NF_N_DEVICES)
#define	CACHE_FBB_SIZE   (NF_CACHE_FBB_LOG_SZ*NF_N_DEVICES)
Enumerations
enum	Nf_sense { NF_READ = 0, NF_WRITE }
Functions
static void	nf_check_fbb (Bool b_ecc_err)
static void	nf_check_lut (void)
Ctrl_status	nf_test_unit_ready (void)
	Initializes the NF driver on the first USB Test Unit Ready.
Ctrl_status	nf_read_capacity (U32 *)
	Returns the address of the last valid logical sector.
Bool	nf_wr_protect (void)
Bool	nf_removal (void)
Ctrl_status	nf_10 (U32 addr, U16 nb_sector, Nf_sense)
Ctrl_status	nf_dfc_read_resume (void)
Ctrl_status	nf_dfc_write_resume (void)
Ctrl_status	nf_dfc_read_stop (U16 remaining_sectors)
Ctrl_status	nf_dfc_write_stop (U16 remaining_sectors)
	This function must be called when a write10 operation (from USB) is finished Last page written is programmed and environment is saved.
void	nf_dfc_read_standby (U16)
void	nf_dfc_read_restart (void)
U32	nf_get_sectors_number (void)
	Returns a pointer on the internal buffer address.
U8 *	nf_get_buffer_addr (void)
void	nf_init (void)
	Initializes the nand flash memory driver.
Status_bool	nf_verify (void)
	Ensure that the memory is in a good state before starting to use it.
Status_bool	nf_verify_resume (void)
	Ensure that the memory is in a good state before starting to use it.
void	nf_cleanup_memory (void)
	Cleanup the memory by erasing all the management blocks.
void	nf_upload (U8 _MEM_TYPE_SLOW_ *, U8)
	Upload packets of 16 bytes from the NAND Flash to RAM.
void	nf_download (U8 _MEM_TYPE_SLOW_ *, U8)
	Download packets of 16 bytes from RAM to the NAND Flash.
U32	nf_block_2_page (U16 block_addr)
void	nf_ecc_mngt (void)
void	nf_sync (void)
void	nf_copy (U32 copy_dst)
	Copy a NF page to a new one.
Status_bool	nf_write_lut (U8 pos, U8 i_sub_lut, U16 sub_lut_log_sz)
	Writes a LUT in memory from a buffer.
Status_bool	nf_write_fbb (void)
	Writes the Free-blocks block into the Nand Flash.
void	nf_cache_fbb_refill (void)
	Reload the FBB cache memory, starting from 0.
void	nf_swap (U8 dev_id, U8 u8_ofst_lut, U8 u8_ofst_fbb)
	Swap 2 blocks from the LUT and the FBB.
void	nf_cache_fbb_flush (Bool)
	Flushes the FBB cache into a new FBB entry.
void	nf_recovery (U16 block_1, U16 block_2)
void	nf_copy_tail (void)
Ctrl_status	nf_read_10 (U32 log_sector, U16 n_sectors)
	This function initializes the Nand Flash for a read operation.
Ctrl_status	nf_write_10 (U32 log_sector, U16 n_sectors)
	This function initializes the Nand Flash for a write operation.
Ctrl_status	nf_ram_2_nf (U32 addr, U8 *ram)
	This fonction initialise the memory for a write operation from ram buffer.
Ctrl_status	nf_nf_2_ram (U32 addr, U8 *ram)
	This fonction read 1 sector from NF to ram buffer.
Variables
_MEM_TYPE_SLOW_ U16	_debug

---

Detailed Description

This file is the header file for the high level management of the nand flash memory devices.

• Compiler: IAR EWAVR and GNU GCC for AVR
• Supported devices: AT90USB1287, AT90USB1286, AT90USB647, AT90USB646

Author:

Atmel Corporation: http://www.atmel.com
Support and FAQ: http://support.atmel.no/

Definition in file nf_mngt.h.

---

Define Documentation

#define NF_BLK_RCV_NO_RECOVERY   0xA5

Definition at line 58 of file nf_mngt.h.

#define NF_BLK_RCV_PENDING_RECOVERY   0x5A

Definition at line 59 of file nf_mngt.h.

#define NF_LOW_N_FREE_THRESHOLD   5

Definition at line 61 of file nf_mngt.h.

Referenced by nf_rebuild().

#define NF_PAGE_BUFFER_SIZE   2048

Definition at line 74 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_lut_flush(), nf_rebuild(), and nf_write_lut().

#define NF_FULL_PAGE_BUFFER_SIZE   ( (NF_PAGE_BUFFER_SIZE) + (NF_PAGE_BUFFER_SIZE)/32 )

Definition at line 79 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), and nf_init_buffer().

#define NF_SHIFT_SUBLUT_PHYS   ( (G_SHIFT_PAGE_BYTE)-1 )

Definition at line 80 of file nf_mngt.h.

Referenced by nf_cache_lut_flush(), nf_cache_lut_refill(), and nf_rebuild().

#define NF_SUBLUT_SIZE   ( 1L<<(NF_SHIFT_SUBLUT_PHYS) )

Definition at line 81 of file nf_mngt.h.

Referenced by nf_cache_lut_flush(), nf_rebuild(), and nf_scan().

#define NF_N_MAX_BLOCKS   (8*1024)

Definition at line 85 of file nf_mngt.h.

#define N_SUBLUT   (NF_N_DEVICES*NF_N_MAX_BLOCKS/(512/2))

Definition at line 86 of file nf_mngt.h.

Referenced by nf_rebuild().

#define S_SHIFT_SECTOR_BYTE   s_shift_sector_byte

Definition at line 101 of file nf_mngt.h.

Referenced by nf_get_sectors_number(), nf_init(), nf_nf_2_ram(), nf_ram_2_nf(), nf_translate(), and nf_write_10().

#define S_SHIFT_LOG_PAGE_SECTOR   s_shift_log_page_sector

Definition at line 102 of file nf_mngt.h.

Referenced by nf_open_write(), and nf_translate().

#define S_SHIFT_LOG_BLOCK_SECTOR   s_shift_log_block_sector

Definition at line 103 of file nf_mngt.h.

Referenced by nf_copy_tail(), nf_ram_2_nf(), nf_rebuild(), nf_translate(), and nf_write_10().

#define S_MNGT_DEV   ((NF_N_DEVICES)-1)

Definition at line 112 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_fbb_refill(), nf_cache_lut_flush(), nf_cache_lut_refill(), nf_check_fbb(), nf_check_lut(), nf_open_write(), nf_rebuild(), nf_scan(), nf_write_fbb(), and nf_write_lut().

#define Nf_check_fbb

(

x

)

nf_check_fbb(x)

Definition at line 118 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_lut_flush(), nf_dfc_write_stop(), nf_translate(), and nf_verify_resume().

 

#define Nf_check_lut

(

)

nf_check_lut()

Definition at line 119 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_lut_flush(), nf_dfc_write_stop(), nf_translate(), and nf_verify_resume().

#define CACHE_LUT_SIZE   (NF_CACHE_LUT_LOG_SZ*NF_N_DEVICES)

Definition at line 134 of file nf_mngt.h.

Referenced by nf_cache_lut_flush(), nf_cache_lut_refill(), and nf_swap().

#define CACHE_FBB_SIZE   (NF_CACHE_FBB_LOG_SZ*NF_N_DEVICES)

Definition at line 147 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_fbb_refill(), and nf_swap().

---

Enumeration Type Documentation

enum Nf_sense

Enumerator:

NF_READ
NF_WRITE

Definition at line 151 of file nf_mngt.h.

{
   NF_READ=0
,  NF_WRITE
} Nf_sense;

---

Function Documentation

static void nf_check_fbb

(

Bool

b_ecc_err

)

[static]

static void nf_check_lut

(

void

)

[static]

Ctrl_status nf_test_unit_ready

(

void

)

Initializes the NF driver on the first USB Test Unit Ready.

Parameters:

none

Returns:

CTRL_GOOD if ok, CTRL_NO_PRESENT in case of problems.

Definition at line 215 of file nf_mngt.c.

References CTRL_FAIL, CTRL_GOOD, nf_verify(), nf_XMCR_disable(), nf_XMCR_enable(), and PASS.

{
  Status_bool tmp_bool;

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   tmp_bool = nf_verify();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   return ( tmp_bool==PASS ) ? CTRL_GOOD : CTRL_FAIL;
}

Here is the call graph for this function:

Ctrl_status nf_read_capacity

(

U32 *

u32_nb_sector

)

Returns the address of the last valid logical sector.

Parameters:

none

Returns:

CTRL_GOOD if ok, CTRL_NO_PRESENT in case of problems.

Definition at line 240 of file nf_mngt.c.

References CTRL_FAIL, CTRL_GOOD, nf_get_sectors_number(), nf_verify(), nf_XMCR_disable(), nf_XMCR_enable(), and PASS.

{
  Status_bool status_bool;

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   status_bool = nf_verify();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   *u32_nb_sector = nf_get_sectors_number()-1;
   return ( status_bool==PASS ) ? CTRL_GOOD : CTRL_FAIL;
}

Here is the call graph for this function:

Bool nf_wr_protect

(

void

)

Definition at line 259 of file nf_mngt.c.

References FALSE.

{
    return FALSE;
}

Bool nf_removal

(

void

)

Definition at line 264 of file nf_mngt.c.

References TRUE.

{
    return TRUE;
}

Ctrl_status nf_10	(	U32	addr,
		U16	nb_sector,
		Nf_sense
	)

Ctrl_status nf_dfc_read_resume

(

void

)

Ctrl_status nf_dfc_write_resume

(

void

)

Ctrl_status nf_dfc_read_stop

(

U16

remaining_sectors

)

Ctrl_status nf_dfc_write_stop

(

U16

u16_nb_sector_remaining

)

This function must be called when a write10 operation (from USB) is finished Last page written is programmed and environment is saved.

Parameters:

	log_sector	Logical sector address to start read
	nb_sector	Number of sectors to transfer

Returns:

CTRL_GOOD if ok, CTRL_FAIL if read outside memory

Definition at line 767 of file nf_mngt.c.

References CTRL_GOOD, FALSE, LSB0, Nf_check_fbb, Nf_check_lut, nf_erase_old_blocks(), NF_N_DEVICES, NF_PAGE_PROGRAM_CMD, NF_TRANS_NORMAL, nf_translate(), nfc_reset_nands(), Nfc_set_cmd, SIZE_BLOCK_PAGE, trace(), trace_hex32(), and trace_nl().

{
   Nfc_set_cmd(NF_PAGE_PROGRAM_CMD); // Program the page
   // Note that if the page is not completely filled in yet but still programmed, the next copy tail will allow partial page program

   // retreive exact logical/physical position (in case that transfer
   // did not perform the exact number of sectors)
   s_curr_log_sector = s_save_log_addr - u16_nb_sector_remaining;
   if( 0!=u16_nb_sector_remaining )
   {
      nf_translate( NF_TRANS_NORMAL );
   }
   g_last_log_sector  = s_curr_log_sector; // Memorize next logical sector to be managed

   // Test if transfer stop at end of logical blocks.
   if( s_n_sectors==0 )
   {
      if(!(LSB0(g_next_phys_page_addr) & (SIZE_BLOCK_PAGE-1))  // new block
      && (g_curr_dev_id==0                                  )) // on device 0.
     {
         // Delete old blocks
         //
         nf_erase_old_blocks();
      }
   }
   trace("nf_dfc_write_stop;"); trace_hex32(g_last_log_sector); trace_nl();

   // Ensure that all internal programming are complete, since we are
   // using cache programming (WP may be asserted for icons or fonts
   // loading). Moreover, on some NFs (ST, Samsung)
   // it is necessary to reset the devices after copy-back commands
   // If not, strange behaviour may happen: no busy when opening
   // a page for reading...
   nfc_reset_nands( NF_N_DEVICES ); // Reset all the NF devices

   Nf_check_fbb( FALSE );
   Nf_check_lut();

   return CTRL_GOOD;
} // end of nf_dfc_write_stop

Here is the call graph for this function:

void nf_dfc_read_standby

(

U16

)

void nf_dfc_read_restart

(

void

)

U32 nf_get_sectors_number

(

void

)

Returns a pointer on the internal buffer address.

This function is used for test only.

Parameters:

none

Returns:

pointer on an internal buffer of 2112 bytes. Returns the total number of sectors that can be used on the memory.

This number is computed during the power on, after a scan of the memory.

Parameters:

none

Returns:

Number of sectors.

Definition at line 293 of file nf_mngt.c.

References G_SHIFT_BLOCK_PAGE, G_SHIFT_PAGE_BYTE, and S_SHIFT_SECTOR_BYTE.

{
   return
      (U32)g_n_export_blocks
   << (G_SHIFT_BLOCK_PAGE +G_SHIFT_PAGE_BYTE -S_SHIFT_SECTOR_BYTE)
   ;
}

U8* nf_get_buffer_addr

(

void

)

void nf_init

(

void

)

Initializes the nand flash memory driver.

The device identification is performed to initialize the driver accordingly

Parameters:

none

Returns:

none

Definition at line 148 of file nf_unusual.c.

Referenced by main().

{
   g_nf_init=FALSE;
//   s_pending_write=FALSE;

#if (NF_GENERIC_DRIVER==TRUE)
#error Check this init...
   g_n_zones             = NF_N_ZONES;
   g_n_blocks            = NF_N_BLOCKS;
   g_shift_block_page    = NF_SHIFT_BLOCK_PAGE;
   g_shift_page_byte     = NF_SHIFT_PAGE_BYTE;
   s_shift_sector_byte   = NF_SHIFT_SECTOR_BYTE;
   g_n_row_cycles        = NF_N_ROW_CYCLES;

   if ( Is_nf_2k() ) // 2KB pages
   {
      g_ofst_blk_status     = 0;
   }
   if ( Is_nf_512() ) // 512B pages
   {
      g_ofst_blk_status     = 5;
   }

   s_shift_log_page_sector  = G_SHIFT_PAGE_BYTE - S_SHIFT_SECTOR_BYTE + NF_SHIFT_N_DEVICES;
   s_shift_log_block_sector = s_shift_log_page_sector + G_SHIFT_BLOCK_PAGE;
#endif

   g_cache_lut.ctrl.valid = FALSE; g_cache_lut.ctrl.dirty = FALSE;
   g_cache_fbb.ctrl.valid = FALSE; g_cache_fbb.ctrl.dirty = FALSE;
   g_last_log_sector= 0xFFFFFFFF;
}

Here is the caller graph for this function:

Status_bool nf_verify

(

void

)

Ensure that the memory is in a good state before starting to use it.

Parameters:

none

Returns:

a status: PASS if the command has been succesfully executed; FAIL else

Definition at line 199 of file nf_mngt.c.

References nf_verify_resume(), and PASS.

{
   if ( g_nf_init ) return PASS;

   return nf_verify_resume();
}

Here is the call graph for this function:

Status_bool nf_verify_resume

(

void

)

Ensure that the memory is in a good state before starting to use it.

The function will scan the memory, test if the memory is valid, clean it if it has to and rebuild all the management blocks. This function shall be called prior to any use of the memory after a power-up.

Parameters:

none

Returns:

a status: PASS if the command has been succesfully executed; FAIL else

Definition at line 193 of file nf_unusual.c.

Referenced by nf_verify().

{
   U8 u8_nb_loop;
   Bool status_bool;


#if (ERASING_ALL==ENABLE)
   ut_nfc_erase_all();
#endif
   
   status_bool = nf_scan();

   if(( PASS!=status_bool )
   || ( is_nf_invalid()   )  // The NF is not cleanly built
   ) {
      // The NF seems not cleanly built, or not built at all.
      //
      u8_nb_loop = 0;
      while( 1 )
      {
         u8_nb_loop++;
         if( u8_nb_loop > 2 )
         {
            status_bool=FAIL;
            break;  // Error NF access or control
         }
         nf_cleanup_memory();
         if( PASS != nf_scan() )
            continue;
         if( PASS != nf_rebuild() )
            continue;
         status_bool = PASS;
         break;
      }
   }
   if (status_bool==PASS)
   {
      g_nf_init = TRUE;
      Nf_check_lut();
      Nf_check_fbb( FALSE );
   }

   return status_bool;
}

Here is the caller graph for this function:

void nf_cleanup_memory

(

void

)

Cleanup the memory by erasing all the management blocks.

The sub-LUT blocks, the recovery block and the free-blocks block will be erased on any devices.

Parameters:

none

Definition at line 247 of file nf_unusual.c.

Referenced by nf_verify_resume().

{
   U8   i_dev  =0;
   U16  i_block=0;
   U8   block_valid;
   U8   block_id;

   // Scan all the devices and looks for:
   // - the sub-LUT
   // - the recovery block
   // - the free-blocks block
   //
   for( i_dev=0 ; i_dev<NF_N_DEVICES ; i_dev++ )
   {
      // Select the devices
      //
      Nfc_action(NFC_ACT_DEV_SELECT, i_dev);

      for( i_block=g_nf_first_block ; i_block<G_N_BLOCKS ; i_block++ )
      {

         nfc_open_page_read( nf_block_2_page(i_block), NF_SPARE_POS);
         block_valid = Nfc_rd_data_fetch_next();
         block_id    = Nfc_rd_data()           ;

         if ( block_valid!=0xFF )
         {
            continue; // The block is bad
         }

         if(( NFC_BLK_ID_SUBLUT==block_id )
         || ( NFC_BLK_ID_FBB   ==block_id ))
         {
            nfc_erase_block( nf_block_2_page(i_block), TRUE ) ;
            if ( FAIL==nfc_check_status() )
            {
               nfc_mark_bad_block( nf_block_2_page(i_block) );
            }
         }
      } // for( i_block...
   } // for( i_dev...
} // nf_cleanup_memory

Here is the caller graph for this function:

void nf_upload	(	U8 _MEM_TYPE_SLOW_ *	datbuf,
		U8	loop
	)

Upload packets of 16 bytes from the NAND Flash to RAM.

Parameters:

U8

* datbuf pointer to RAM U8 loop number of 16 bytes packets

Returns:

none

Definition at line 1696 of file nf_mngt.c.

References _MEM_TYPE_SLOW_, and Nf_rd_byte.

{
  U8 _MEM_TYPE_SLOW_ * tempbuf = datbuf;
  U8 i = loop;

  while (i != 0)
  {
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     *(tempbuf) = Nf_rd_byte(); tempbuf++;
     i--;
  }
}

void nf_download	(	U8 _MEM_TYPE_SLOW_ *	datbuf,
		U8	loop
	)

Download packets of 16 bytes from RAM to the NAND Flash.

Parameters:

U8

* datbuf pointer to RAM U8 loop number of 16 bytes packets

<global parameters>="">

Returns:

none

Definition at line 1660 of file nf_mngt.c.

References _MEM_TYPE_SLOW_, and Nf_wr_byte.

{
  U8 _MEM_TYPE_SLOW_ * tempbuf = datbuf;
  U8 i = loop;

  while (i != 0)
  {
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     Nf_wr_byte(*(tempbuf)); tempbuf++;
     i--;
  }
}

U32 nf_block_2_page

(

U16

block_addr

)

Definition at line 303 of file nf_mngt.c.

References G_SHIFT_BLOCK_PAGE.

{
   return (U32)block_addr<<G_SHIFT_BLOCK_PAGE;
}

void nf_ecc_mngt

(

void

)

void nf_sync

(

void

)

void nf_copy

(

U32

copy_dst

)

Copy a NF page to a new one.

This function copies a NF page into a new page. It uses the copy-back command if it is possible.

Parameters:

	g_copy_src	(global) Source page address
	copy_dst	Recipient page address

Definition at line 1856 of file nf_mngt.c.

References G_COPY_BACK_CONT, G_COPY_BACK_DISCONT, G_N_ROW_CYCLES, G_N_ZONES, G_SHIFT_BLOCK_PAGE, G_SHIFT_PAGE_BYTE, Is_nf_2k, LSB, LSB0, LSB1, MSB, MSB1, nf_download(), NF_PAGE_PROGRAM_CMD, NF_RANDOM_DATA_INPUT_CMD, NF_SPARE_POS, nf_upload(), nfc_copy_back_init(), NFC_OFST_3_DATA_DST, nfc_open_page_read(), nfc_open_page_write(), Nfc_set_adc, Nfc_set_adr, Nfc_set_cmd, NFC_SPARE_OFST_3_BYTE_3, NFC_SPARE_OFST_6_LBA, Nfc_unprotect_all_flash, and Nfc_wr_data.

{
   Bool b_copy_fast;
   U8   zone_A, zone_B;

   // Compute the possibility of fast copy
   if( 0 == G_COPY_BACK_CONT )
   {
      b_copy_fast = 0;     // never possible
   }
   else
   {
      if( (1 == G_COPY_BACK_CONT) && (1==G_COPY_BACK_DISCONT) )
      {
         b_copy_fast = 1;  // always possible
      }
      else
      {
         // Check block address
         b_copy_fast = 1;  // by default possible
         if( 1 != G_COPY_BACK_CONT )
         {
/*
            zone_A = (g_copy_src>>G_SHIFT_BLOCK_PAGE) / ((U16)G_N_BLOCKS/G_COPY_BACK_CONT);
            zone_B = (copy_dst  >>G_SHIFT_BLOCK_PAGE) / ((U16)G_N_BLOCKS/G_COPY_BACK_CONT);
*/
            // block_zone = page add / number of page / 1024
            if( Is_nf_2k() )
            {
               // block_zone = (page add >> (G_SHIFT_BLOCK_PAGE + 10)) / (G_N_ZONES/G_COPY_BACK_CONT);
               // block_zone = ((page add >> 16) * G_COPY_BACK_CONT) / G_N_ZONES;
               zone_A = (MSB1(g_copy_src)*G_COPY_BACK_CONT)/G_N_ZONES;
               zone_B = (MSB1(copy_dst  )*G_COPY_BACK_CONT)/G_N_ZONES;
            }else{
               // block_zone = page add >> (G_SHIFT_BLOCK_PAGE + 10) / (G_N_ZONES/G_COPY_BACK_CONT);
               zone_A = ((U8)(g_copy_src>>(G_SHIFT_BLOCK_PAGE + 10)) *G_COPY_BACK_CONT) /G_N_ZONES;
               zone_B = ((U8)(copy_dst  >>(G_SHIFT_BLOCK_PAGE + 10)) *G_COPY_BACK_CONT) /G_N_ZONES;
            }
            if( zone_A != zone_B )
               b_copy_fast = 0;     // no possible
         }
         if( 1 != G_COPY_BACK_DISCONT )
         {
// define mandatory to delete compile error on MODULO 0
#if (NF_GENERIC_DRIVER==TRUE) || (NF_AUTO_DETECT_2KB==TRUE) || (NF_AUTO_DETECT_512B==TRUE)
            zone_A = ((U16)g_copy_src>>G_SHIFT_BLOCK_PAGE) % G_COPY_BACK_DISCONT;
            zone_B = ((U16)copy_dst  >>G_SHIFT_BLOCK_PAGE) % G_COPY_BACK_DISCONT;
#elif ( G_COPY_BACK_DISCONT != 0 )
            zone_A = ((U16)g_copy_src>>G_SHIFT_BLOCK_PAGE) % G_COPY_BACK_DISCONT;
            zone_B = ((U16)copy_dst  >>G_SHIFT_BLOCK_PAGE) % G_COPY_BACK_DISCONT;
#endif
            if( zone_A != zone_B )
               b_copy_fast = 0;     // no possible
         }
      }
   }
      
   // Start copy
   if( !b_copy_fast )
   {
      // copy the page of the old block in buffer
      nfc_open_page_read( g_copy_src, 0 );
      nf_upload(                                // Works by packet of 16 bytes
         g_page_buffer
      ,     ((U16)1<<(G_SHIFT_PAGE_BYTE-4))     // Data zone (Page size / 16)
         +  ((U16)1<<(G_SHIFT_PAGE_BYTE-5-4))); // Spare zone (Page size / 32 / 16)

      // Add LBA markers to help recovery function
      // Need to explain a bit why LBA are written: 
      // nf_copy is called from copy_head and copy_tail.
      // - copy_head: need to write all the LBA of the pages to help recovery finding
      //   where the last sector is written.
      //   Moreover, in case that nf_copy is called from copy_head and source block at page 0
      //   does not contain LBA.
      // - copy_tail: no need to mark the last LBA of the last page to identify the source
      //   block since we use another method
      g_page_buffer[NF_SPARE_POS+NFC_SPARE_OFST_3_BYTE_3] = NFC_OFST_3_DATA_DST;  // 3- [SW] Source block (recovery) (HW capability not used)
      g_page_buffer[NF_SPARE_POS+NFC_SPARE_OFST_6_LBA   ] = MSB(g_log_block_id);  // 6- LBA
      g_page_buffer[NF_SPARE_POS+NFC_SPARE_OFST_6_LBA+1 ] = LSB(g_log_block_id);  // 7- LBA
      if( Is_nf_2k() )
      {
         g_page_buffer[NF_SPARE_POS +16*1 +NFC_SPARE_OFST_6_LBA  ] =
         g_page_buffer[NF_SPARE_POS +16*2 +NFC_SPARE_OFST_6_LBA  ] =
         g_page_buffer[NF_SPARE_POS +16*3 +NFC_SPARE_OFST_6_LBA  ] = MSB(g_log_block_id);  // 6- LBA
         g_page_buffer[NF_SPARE_POS +16*1 +NFC_SPARE_OFST_6_LBA+1] =
         g_page_buffer[NF_SPARE_POS +16*2 +NFC_SPARE_OFST_6_LBA+1] =
         g_page_buffer[NF_SPARE_POS +16*3 +NFC_SPARE_OFST_6_LBA+1] = LSB(g_log_block_id);  // 7- LBA
      }

      // copy the buffer in the page of the new block
      nfc_open_page_write( copy_dst, 0 );
      nf_download(                                // Works by packet of 16 bytes
         g_page_buffer
      ,     ((U16)1<<(G_SHIFT_PAGE_BYTE-4))       // Data zone (Page size / 16)
         +  ((U16)1<<(G_SHIFT_PAGE_BYTE-5-4)));  // Spare zone (Page size / 32 / 16)
      Nfc_set_cmd(NF_PAGE_PROGRAM_CMD);
   }
   else
   {
      nfc_copy_back_init( g_copy_src );

      Nfc_unprotect_all_flash();                              // WP may be actif due to block protection
      Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
      Nfc_set_adc( (NF_SPARE_POS+NFC_SPARE_OFST_3_BYTE_3)%256 );
      Nfc_set_adc( (NF_SPARE_POS+NFC_SPARE_OFST_3_BYTE_3)/256 );
      Nfc_set_adr( LSB0(copy_dst) );
      Nfc_set_adr( LSB1(copy_dst) );
      if ( 3==G_N_ROW_CYCLES )
      {
         Nfc_set_adr( MSB1(copy_dst) );
      }

      // Remove Source block mask
      Nfc_wr_data( NFC_OFST_3_DATA_DST );

      // Add LBA markers to help recovery function
      Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
      Nfc_set_adc( (NF_SPARE_POS+NFC_SPARE_OFST_6_LBA)%256 );
      Nfc_set_adc( (NF_SPARE_POS+NFC_SPARE_OFST_6_LBA)/256 );
      Nfc_wr_data( MSB(g_log_block_id) );
      Nfc_wr_data( LSB(g_log_block_id) );

      if( Is_nf_2k() )
      {
         Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
         Nfc_set_adc( (NF_SPARE_POS + 16*1 +NFC_SPARE_OFST_6_LBA)%256 );
         Nfc_set_adc( (NF_SPARE_POS + 16*1 +NFC_SPARE_OFST_6_LBA)/256 );
         Nfc_wr_data( MSB(g_log_block_id) );
         Nfc_wr_data( LSB(g_log_block_id) );

         Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
         Nfc_set_adc( (NF_SPARE_POS + 16*2 +NFC_SPARE_OFST_6_LBA)%256 );
         Nfc_set_adc( (NF_SPARE_POS + 16*2 +NFC_SPARE_OFST_6_LBA)/256 );
         Nfc_wr_data( MSB(g_log_block_id) );
         Nfc_wr_data( LSB(g_log_block_id) );

         Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
         Nfc_set_adc( (NF_SPARE_POS + 16*3 +NFC_SPARE_OFST_6_LBA)%256 );
         Nfc_set_adc( (NF_SPARE_POS + 16*3 +NFC_SPARE_OFST_6_LBA)/256 );
         Nfc_wr_data( MSB(g_log_block_id) );
         Nfc_wr_data( LSB(g_log_block_id) );
      }
      Nfc_set_cmd(NF_PAGE_PROGRAM_CMD);
   }
}

Here is the call graph for this function:

Status_bool nf_write_lut	(	U8	pos,
		U8	i_sub_lut,
		U16	sub_lut_log_sz
	)

Writes a LUT in memory from a buffer.

Parameters:

	pos	offset of the lub-lut in the buffer
	i_sub_lut	id of the sub-LUT
	sub_lut_log_sz	Size of the sub-LUT, in logical block unit

Returns:

nothing

Definition at line 1210 of file nf_mngt.c.

References _debug, _MEM_TYPE_SLOW_, Assert, FAIL, G_N_BLOCKS, G_SHIFT_PAGE_BYTE, LSB, MSB, nf_block_2_page(), NF_N_DEVICES, NF_PAGE_BUFFER_SIZE, NF_PAGE_PROGRAM_CMD, NFC_ACT_DEV_SELECT, Nfc_action, NFC_BLK_ID_SUBLUT, nfc_check_status(), nfc_open_page_write(), Nfc_set_cmd, Nfc_wr_data, PASS, S_MNGT_DEV, trace(), trace_hex(), trace_hex16(), and trace_nl().

{
   U16  block_addr; // Physical block number
   U8 _MEM_TYPE_SLOW_ * p_buf=g_page_buffer + (U16)pos*((U16)1<<(G_SHIFT_PAGE_BYTE));

   Nfc_action(NFC_ACT_DEV_SELECT, S_MNGT_DEV);
   // The buffer is built as:
   // |    512    |    512    |    512    |    512    |
   //
   // The page is built as:
   // |    512    |    512    |    512    |    512    |SZ|
   //
   // The LUT fits in a physical page.
   //
   nfc_open_page_write(
      nf_block_2_page( g_lut_block_addr[i_sub_lut] ) // base address
   +  (U32)(g_lut_block_index[i_sub_lut])            // offset to sub-LUT
   ,  0 );

   trace("nf_write_lut;");trace_hex16(g_lut_block_addr[i_sub_lut]); trace(";"); trace_hex16(g_lut_block_index[i_sub_lut]);trace_nl();
   for( block_addr=0 ; block_addr<((U16)1<<(G_SHIFT_PAGE_BYTE-1)) ; block_addr+=1 )
   {
      if ( block_addr<(sub_lut_log_sz*NF_N_DEVICES) )
      {
#if (_ASSERT_==ENABLE)
         Assert(           ( block_addr*2)<(NF_PAGE_BUFFER_SIZE-1) );
         MSB(_debug)= p_buf[ block_addr*2   ] ;
         LSB(_debug)= p_buf[ block_addr*2 +1] ;
         Assert( _debug>=g_nf_first_block );
         Assert( _debug< G_N_BLOCKS       );
#endif
         Nfc_wr_data( p_buf[ block_addr*2   ] );
         Nfc_wr_data( p_buf[ block_addr*2 +1] );
         trace_hex(p_buf[ block_addr*2   ]);
         trace_hex(p_buf[ block_addr*2 +1]);
         trace("-");
      }
      else
      {
         Nfc_wr_data( 0xFF );
         Nfc_wr_data( 0xFF );
         trace("FFFF-");
      }
   }
   trace_nl();

   // Write the spare information
   //
   Nfc_wr_data( 0xFF              );                              // 0- block is valid (for 2048 compatibility)
   Nfc_wr_data( NFC_BLK_ID_SUBLUT );                              // 1- sub-LUT
   Nfc_wr_data( i_sub_lut         );                              // 2- sub-LUT id
   Nfc_wr_data( 0xFF              );                              // 3- unused
   Nfc_wr_data( g_n_sub_lut       );                              // 4- number of sub-LUT
   Nfc_wr_data( 0xFF              );                              // 5- block is valid (for 512 compatibility)
   Nfc_wr_data( MSB(sub_lut_log_sz) );                            // 6-7 Number of log blocks in sub-LUT
   Nfc_wr_data( LSB(sub_lut_log_sz) );
   Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); // 8-9-10-   ECC2
   Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF );                      // 11-12-    LBA
   Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); // 13-14-15- ECC1

   Nfc_set_cmd( NF_PAGE_PROGRAM_CMD );
   if ( FAIL==nfc_check_status() ) { return FAIL; }

   return PASS;
} // end of nf_write_lut

Here is the call graph for this function:

Status_bool nf_write_fbb

(

void

)

Writes the Free-blocks block into the Nand Flash.

Parameters:

none

Returns:

nothing

Definition at line 1414 of file nf_mngt.c.

References FAIL, G_SHIFT_PAGE_BYTE, LSB, MSB, nf_block_2_page(), NF_PAGE_PROGRAM_CMD, NFC_ACT_DEV_SELECT, Nfc_action, NFC_BLK_ID_FBB, nfc_check_status(), NFC_OFST_4_FBB_DRIVER_RELEASE, NFC_OFST_6_FBB_VALID, nfc_open_page_write(), Nfc_set_cmd, Nfc_wr_data, PASS, and S_MNGT_DEV.

{
   U16 u16_tmp;

   Nfc_action(NFC_ACT_DEV_SELECT, S_MNGT_DEV);
   nfc_open_page_write(
      nf_block_2_page( g_fbb_block_addr )  // base address
   +  (U32)g_fbb_block_index               // offset to Free-blocks block entry
   , 0 );
   for ( u16_tmp=0 ; u16_tmp<((U16)1<<(G_SHIFT_PAGE_BYTE-1)) ; )
   {
      if ( u16_tmp<g_n_free_blocks )
      {
         Nfc_wr_data( g_page_buffer[2*u16_tmp   ] );
         Nfc_wr_data( g_page_buffer[2*u16_tmp +1] );
      }
      else
      {
         Nfc_wr_data( 0xFF );
         Nfc_wr_data( 0xFF );
      }
      u16_tmp++;
   }
   // Write the spare information
   //
   Nfc_wr_data( 0xFF );                                           // 0- block is valid (for 2048 compatibility)
   Nfc_wr_data( NFC_BLK_ID_FBB );                                 // 1- Free-blocks block
   Nfc_wr_data( MSB(g_n_free_blocks));                            // 2-3 Number of free blocks
   Nfc_wr_data( LSB(g_n_free_blocks));
   Nfc_wr_data( NFC_OFST_4_FBB_DRIVER_RELEASE );                  // 4- Nand-Flash driver ID
   Nfc_wr_data( 0xFF );                                           // 5- block is valid (for 512 compatibility)
   Nfc_wr_data( NFC_OFST_6_FBB_VALID );                           // 6- FBB-LUTs valid
   Nfc_wr_data( 0xFF );                                           // 7- Unused
   Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); // 8-9-10-   Unused
   Nfc_wr_data( MSB(g_n_export_blocks));                          // 11-12- Number of exported blocks
   Nfc_wr_data( LSB(g_n_export_blocks));
   Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); Nfc_wr_data( 0xFF ); // 13-14-15- Unused

   Nfc_set_cmd( NF_PAGE_PROGRAM_CMD );
   if ( FAIL==nfc_check_status() ) { return FAIL; }
   return PASS;
} // end of nf_write_fbb

Here is the call graph for this function:

void nf_cache_fbb_refill

(

void

)

Reload the FBB cache memory, starting from 0.

The cache is filled with physical blocks.

Parameters:

none

Returns:

nothing

Definition at line 1046 of file nf_mngt.c.

References _MEM_TYPE_SLOW_, Assert, CACHE_FBB_SIZE, FALSE, G_N_BLOCKS, LSB, Min, MSB, nf_block_2_page(), NF_CACHE_FBB_LOG_SZ, NF_N_DEVICES, NFC_ACT_DEV_SELECT, Nfc_action, nfc_open_page_read(), Nfc_rd_data_fetch_next, S_MNGT_DEV, SIZE_PAGE_BYTE, trace(), trace_hex16(), trace_nl(), and TRUE.

{
   U8  u8_tmp;
   U16 byte_addr;
   _MEM_TYPE_SLOW_ U32 page_addr;

   Assert(g_cache_fbb.ctrl.dirty==FALSE); // No refill if the cache is dirty
   g_cache_fbb.p   = 0;

   trace("nf_cache_fbb_refill;"); trace_hex16(g_fbb_block_addr);trace_nl();

   // Ensure that the cache is bigger than the real number of free blocks
   //
   g_cache_fbb.max = Min(NF_CACHE_FBB_LOG_SZ, (g_n_free_blocks>>NF_SHIFT_N_DEVICES) ); // Last included

   Nfc_action(NFC_ACT_DEV_SELECT, S_MNGT_DEV);

   page_addr =
      nf_block_2_page( g_fbb_block_addr  ) // base address
   +  (U32)g_fbb_block_index               // offset to Free-blocks block entry
   ;
   byte_addr=0;

   nfc_open_page_read(page_addr, 0);

   for ( u8_tmp=0 ; u8_tmp<g_cache_fbb.max*NF_N_DEVICES ; u8_tmp++ )
   { // fill the cache buffer
      Assert( u8_tmp<CACHE_FBB_SIZE);
      MSB(g_cache_fbb.mem[u8_tmp]) = Nfc_rd_data_fetch_next();
      LSB(g_cache_fbb.mem[u8_tmp]) = Nfc_rd_data_fetch_next();
      Assert( g_cache_fbb.mem[u8_tmp]>=g_nf_first_block );
      Assert( g_cache_fbb.mem[u8_tmp]< G_N_BLOCKS       );
      byte_addr+=2;
      Assert( byte_addr<SIZE_PAGE_BYTE); // Should stay in the page. Algo limitation.
   }
   g_cache_fbb.ctrl.valid = TRUE;
} // end of nf_cache_fbb_refill

Here is the call graph for this function:

void nf_swap	(	U8	dev_id,
		U8	u8_ofst_lut,
		U8	u8_ofst_fbb
	)

Swap 2 blocks from the LUT and the FBB.

This function swaps 2 blocks: one taken into the LUT according to the LBA, and one from the FBB. This is used when modifying a block. The g_block_to_kill[] holds the block address source (LUT) that will be erased after processing.

Parameters:

	dev_id	Device Id of recipient page
	u8_ofst_lut	block offset in LUT
	u8_ofst_fbb	block offset in FBB

Returns:

none

Definition at line 2018 of file nf_mngt.c.

References Assert, CACHE_FBB_SIZE, CACHE_LUT_SIZE, G_N_BLOCKS, NF_N_DEVICES, trace(), trace_hex32(), trace_nl(), trace_u8(), and TRUE.

{
   Assert( dev_id      < NF_N_DEVICES  );
   Assert( u8_ofst_lut < CACHE_LUT_SIZE);
   Assert( u8_ofst_fbb < CACHE_FBB_SIZE);
   Assert( g_cache_lut.mem[u8_ofst_lut]  >=g_nf_first_block );
   Assert( g_cache_lut.mem[u8_ofst_lut]  < G_N_BLOCKS       );
   Assert( g_cache_fbb.mem[u8_ofst_fbb]  >=g_nf_first_block );
   Assert( g_cache_fbb.mem[u8_ofst_fbb]  < G_N_BLOCKS       );
   g_block_to_kill[dev_id     ] = g_cache_lut.mem[u8_ofst_lut] ;
   g_cache_lut.mem[u8_ofst_lut] = g_cache_fbb.mem[u8_ofst_fbb] ;
   g_cache_fbb.mem[u8_ofst_fbb] = g_block_to_kill[dev_id]      ;
   trace("g_cache_lut.mem["); trace_u8(u8_ofst_lut); trace("] = "); trace_hex32(g_cache_lut.mem[u8_ofst_lut]); trace_nl();
   trace("g_cache_fbb.mem["); trace_u8(u8_ofst_fbb); trace("] = "); trace_hex32(g_cache_fbb.mem[u8_ofst_fbb]); trace_nl();

   // both FBB and LUT caches becomes invalid
   g_cache_lut.ctrl.dirty=TRUE;
   g_cache_fbb.ctrl.dirty=TRUE;
}

Here is the call graph for this function:

void nf_cache_fbb_flush

(

Bool

b_ecc_err

)

Flushes the FBB cache into a new FBB entry.

A copy of the current FBB is made in a new page, taking into account the last FBB modification in its cache. If the block containing the FBB is full, a new block is taken from the FBB itself.

Parameters:

b_ecc_err

FALSE: normal operation, b_ecc_err TRUE: remove a block from list (p)

Returns:

nothing

Definition at line 1292 of file nf_mngt.c.

References _debug, _MEM_TYPE_SLOW_, Assert, CACHE_FBB_SIZE, FALSE, G_N_BLOCKS, G_SHIFT_BLOCK_PAGE, LSB, MSB, nf_block_2_page(), Nf_check_fbb, Nf_check_lut, NF_FULL_PAGE_BUFFER_SIZE, NF_N_DEVICES, NF_PAGE_BUFFER_SIZE, nf_write_fbb(), NFC_ACT_DEV_SELECT, Nfc_action, nfc_erase_block(), nfc_open_page_read(), Nfc_rd_data_fetch_next, S_MNGT_DEV, SIZE_PAGE_BYTE, trace(), trace_hex16(), trace_nl(), and TRUE.

{
   _MEM_TYPE_SLOW_ U32  page_addr;
   _MEM_TYPE_SLOW_ U16  byte_addr;
   _MEM_TYPE_SLOW_ U16 u16_delete=0;
   _MEM_TYPE_SLOW_ U16  u16_tmp;
   U8   u8_tmp;
   _MEM_TYPE_SLOW_ U8   u8_pos;
   Bool bool_delete=FALSE;

   Assert(TRUE==g_cache_fbb.ctrl.valid);
   Assert(TRUE==g_cache_fbb.ctrl.dirty);
   // Assert(g_cache_fbb.p==(g_cache_fbb.max-1)); This is no more the case for ECC error not correctable

   Nfc_action(NFC_ACT_DEV_SELECT, S_MNGT_DEV);

   trace("nf_cache_fbb_flush;"); trace_hex16(g_fbb_block_addr);trace_nl();

   page_addr=
      nf_block_2_page( g_fbb_block_addr  )  // base address
   +  (U32)g_fbb_block_index                // offset to page
   ;

   g_fbb_block_index++;

   if ( g_fbb_block_index ==  (1<<G_SHIFT_BLOCK_PAGE)/(1<<0) )
   {  // Need to recycle the FBB block itself, using a free-block ! This is always possible
      // since there is always a free block (.p=.max-1) specially for that purpose.
      byte_addr = ((U16)NF_N_DEVICES*g_cache_fbb.p + S_MNGT_DEV);

      Assert( g_cache_fbb.mem[byte_addr]>=g_nf_first_block );
      Assert( g_cache_fbb.mem[byte_addr]< G_N_BLOCKS       );
      u16_delete                 = g_fbb_block_addr           ;
      g_fbb_block_addr           = g_cache_fbb.mem[byte_addr] ;
      g_cache_fbb.mem[byte_addr] = u16_delete;
      g_fbb_block_index = 0;

      trace("nf_cache_fbb_flush;swap;"); trace_hex16(g_fbb_block_addr);trace_nl();
      
      // g_cache_fbb.ctrl.dirty=TRUE; This is already the case !

      g_cache_fbb.p++;
      bool_delete=TRUE;
   }

   if( !b_ecc_err )  { u8_pos = g_cache_fbb.p;   }
   else              { u8_pos = g_cache_fbb.max; }

   byte_addr = ((U16)NF_N_DEVICES*2*u8_pos);

   Assert( byte_addr<SIZE_PAGE_BYTE );

   nfc_open_page_read( page_addr, byte_addr);

   Assert( g_cache_fbb.p<=(g_n_free_blocks/NF_N_DEVICES) );
   for (
      u16_tmp=0
   ;  u16_tmp<((g_n_free_blocks/NF_N_DEVICES)-u8_pos)*NF_N_DEVICES*2
   ; )
   {  // Move the free-blocks after <pos> to the beginning of the buffer.
      Assert( u16_tmp<(NF_PAGE_BUFFER_SIZE-3) );
      g_page_buffer[u16_tmp++] = Nfc_rd_data_fetch_next();
      g_page_buffer[u16_tmp++] = Nfc_rd_data_fetch_next();
#if (_ASSERT_==ENABLE)
      MSB(_debug)= g_page_buffer[u16_tmp-2];
      LSB(_debug)= g_page_buffer[u16_tmp-1];
      Assert( _debug>=g_nf_first_block );
      Assert( _debug< G_N_BLOCKS       );
#endif
   }

   for ( u8_tmp=0 ; u8_tmp<(u8_pos*NF_N_DEVICES); u8_tmp++ )
   {  // Then add the cache content
      Assert( u8_tmp < CACHE_FBB_SIZE );
      Assert( u16_tmp< NF_FULL_PAGE_BUFFER_SIZE );
#if (_ASSERT_==ENABLE)
      // When coming from ECC 2-bits error, an entry has been removed
      // from the cache, so the last entry is 0xffff
      if( !b_ecc_err )
      {
         Assert( g_cache_fbb.mem[u8_tmp]>=g_nf_first_block );
         Assert( g_cache_fbb.mem[u8_tmp]< G_N_BLOCKS       );
      }
#endif
      g_page_buffer[u16_tmp++] = MSB(g_cache_fbb.mem[u8_tmp]);
      g_page_buffer[u16_tmp++] = LSB(g_cache_fbb.mem[u8_tmp]);
   }
#if (_ASSERT_==ENABLE)
   // Ensure that, when there is no fbb recycle, the blocks in the cache at
   // position p are identical to the blocks in the beginning of the new line.
   if( (FALSE==bool_delete) && ( !b_ecc_err ))
   {
      for ( u8_tmp=0 ; u8_tmp<NF_N_DEVICES ; u8_tmp++ )
      {
         MSB(_debug)= g_page_buffer[u8_tmp*2   ];
         LSB(_debug)= g_page_buffer[u8_tmp*2 +1];
         Assert( _debug==g_cache_fbb.mem[(g_cache_fbb.p)*NF_N_DEVICES + u8_tmp] );
      }
   }
#endif

   nf_write_fbb(); // Should test the result
   Nf_check_fbb( b_ecc_err );
   Nf_check_lut();

   if( TRUE==bool_delete )
   {
      nfc_erase_block( nf_block_2_page( u16_delete ), TRUE );
   }

   Assert( u16_tmp==(g_n_free_blocks*2) ); // All the list should have been processed
   g_cache_fbb.ctrl.dirty=FALSE;
} // end of nf_cache_fbb_flush

Here is the call graph for this function:

void nf_recovery	(	U16	block_1,
		U16	block_2
	)

void nf_copy_tail

(

void

)

Definition at line 1555 of file nf_mngt.c.

References _MEM_TYPE_SLOW_, Is_not_nf_512, LSB0, nf_block_2_page(), nf_copy(), nf_download(), nf_erase_old_blocks(), NF_N_DEVICES, NF_PAGE_PROGRAM_CMD, NF_RANDOM_DATA_INPUT_CMD, NF_SPARE_POS, nf_upload(), NFC_ACT_DEV_SELECT, Nfc_action, nfc_open_page_read(), nfc_open_page_write(), Nfc_set_adc, Nfc_set_cmd, S_SHIFT_LOG_BLOCK_SECTOR, SIZE_BLOCK_PAGE, SIZE_PAGE_SECTOR, SIZE_SECTOR_BYTE, trace(), trace_hex32(), and trace_nl().

{
   _MEM_TYPE_SLOW_ U8  u8_tmp;
                   U8  u8_tmp2;
   _MEM_TYPE_SLOW_ U16 u16_tmp;
   _MEM_TYPE_SLOW_ U16 byte_addr;

   // Test if we do not reach the end of the logical block
   //
   if( 0!=((U16)g_last_log_sector & ( ((U16)1<<(S_SHIFT_LOG_BLOCK_SECTOR)) -1)) )
   {
      trace("nf_copy_tail;"); trace_hex32(g_last_log_sector); trace_nl();
      if( Is_not_nf_512() )
      {  // Following is not possible on 512B Nand

         u8_tmp = // current offset sector in the current page
            LSB0(g_last_log_sector)
         &  ( SIZE_PAGE_SECTOR-1 )
         ;

         u8_tmp2 = SIZE_PAGE_SECTOR -u8_tmp;
         if( 0!=u8_tmp )
         {  // Copy the rest of the current line

            byte_addr=((U16)u8_tmp) * (SIZE_SECTOR_BYTE);
            Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);  // open the current device
            nfc_open_page_read(                                                       // Open the old block at :
                  nf_block_2_page( g_block_to_kill[g_curr_dev_id] )                   // adresse of the beginning of the old block
               +  (LSB0(g_phys_page_addr[g_curr_dev_id])&(SIZE_BLOCK_PAGE -1))        // current offset page in the old and new block
            ,  byte_addr );                                                           // current offset sector in the current page
            // for each sector in the physical page
            u16_tmp = u8_tmp2 * SIZE_SECTOR_BYTE;
            g_last_log_sector += u8_tmp2;                                             // update the current logical sector

            // read the sector of the old page
            nf_upload(g_page_buffer+byte_addr, u16_tmp/16 );

            // Read the associated spare zone
            byte_addr= NF_SPARE_POS + (((U16)u8_tmp)*16);
            nfc_open_page_read(                                                       // Open the old block at :
                  nf_block_2_page( g_block_to_kill[g_curr_dev_id] )                   // adresse of the beginning of the old block
               +  (LSB0(g_phys_page_addr[g_curr_dev_id])&(SIZE_BLOCK_PAGE -1))        // current offset page in the old and new block
            ,  byte_addr );                                                           // current offset sector in the current page
            nf_upload(g_page_buffer+byte_addr, u8_tmp2 );

            byte_addr=((U16)u8_tmp) * (SIZE_SECTOR_BYTE);
            nfc_open_page_write( // Open the new block at the current position
               g_phys_page_addr[g_curr_dev_id]
            ,  byte_addr );

            // write the sector in the new page
            nf_download(g_page_buffer+byte_addr, (U8)(u16_tmp/16) );

            // write the associated spare zone
            byte_addr=NF_SPARE_POS + (((U16)u8_tmp)*16);
            Nfc_set_cmd(NF_RANDOM_DATA_INPUT_CMD);
            Nfc_set_adc( (byte_addr)%256 );
            Nfc_set_adc( (byte_addr)/256 );
            nf_download(g_page_buffer+byte_addr, u8_tmp2 );
            Nfc_set_cmd(NF_PAGE_PROGRAM_CMD);

            g_phys_page_addr[g_curr_dev_id]++;                                                   // update the current physical page of the current device
            g_curr_dev_id++;                                                                     // update the current device
            if( g_curr_dev_id==NF_N_DEVICES ) { g_curr_dev_id=0; }
         }
      }

      // then copy the rest of the logical block
      //
      while( 0!=((U16)g_last_log_sector & (((U16)1<<(S_SHIFT_LOG_BLOCK_SECTOR))-1)) )
      {
         Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);  // open the current device

         g_copy_src=
            nf_block_2_page(g_block_to_kill[g_curr_dev_id])                     // adresse of the beginning of the old block
         +  (LSB0(g_phys_page_addr[g_curr_dev_id])&(SIZE_BLOCK_PAGE -1))        // current offset page in the old and new block
         ;
         nf_copy(g_phys_page_addr[g_curr_dev_id]);
         g_phys_page_addr[g_curr_dev_id]++;

         g_last_log_sector+=SIZE_PAGE_SECTOR;                            // update the current logical sector
         g_curr_dev_id++;                                                          // update the current device
         if( g_curr_dev_id==NF_N_DEVICES ) { g_curr_dev_id=0; }
      }

      // Delete old blocks
      //
      nf_erase_old_blocks();
   }else{
      trace("nf_copy_tail empty??;"); trace_hex32(g_last_log_sector); trace_nl();
   }
   g_last_log_sector= 0xFFFFFFFF;
}

Here is the call graph for this function:

Ctrl_status nf_read_10	(	U32	log_sector,
		U16	n_sectors
	)

This function initializes the Nand Flash for a read operation.

Parameters:

	log_sector	Logical sector address to start read
	nb_sector	Number of sectors to transfer

Returns:

CTRL_GOOD if ok, CTRL_FAIL if read outside memory

Definition at line 317 of file nf_mngt.c.

References CTRL_FAIL, CTRL_GOOD, FALSE, LSB0, Nf_access_signal_off, Nf_access_signal_on, nf_get_sectors_number(), nf_open_read(), nf_read_sector_to_usb(), nf_xfer_update_vars(), nf_XMCR_disable(), nf_XMCR_enable(), NFC_ACT_DEV_SELECT, Nfc_action, Nfc_open_page_read, nfc_open_page_read(), SIZE_BLOCK_PAGE, trace(), trace_hex16(), trace_hex32(), trace_nl(), and TRUE.

{
  U8  status;
  
   if ( !g_nf_init )
      while(1);   // You shall call once mem_test_unit_ready() before.

   // Test that the logical sector address is valid
   //
   if ( 0==n_sectors )                                   { return CTRL_GOOD; }
   if ( (log_sector+n_sectors)>nf_get_sectors_number() ) { return CTRL_FAIL; }

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   s_n_sectors       = n_sectors;
   s_curr_log_sector = log_sector;
   trace("rd;"); trace_hex32(s_curr_log_sector); trace(";"); trace_hex16(s_n_sectors); trace_nl();
   s_save_log_addr   = log_sector + n_sectors;
   g_fatal           = FALSE;
   s_mem             = TRUE;
   s_start           = TRUE;

   // First read operation
   Nf_access_signal_on();
   nf_open_read(TRUE);
   Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);
   nfc_open_page_read( g_phys_page_addr[g_curr_dev_id], s_curr_n_byte );
   nf_read_sector_to_usb(s_nb_sectors_step);
   status = nf_xfer_update_vars();

   // Next read operations
   while (status == FALSE)    // exit when last page read
   {
      if (!(LSB0(g_next_phys_page_addr) & (SIZE_BLOCK_PAGE-1))    // new block
      && (g_curr_dev_id==0                                  ))    // on device 0. Should this case be implicit ? If yes, we can remove it.
      {
         nf_open_read(FALSE);
      }
      Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);
      Nfc_open_page_read( g_next_phys_page_addr, s_curr_n_byte ); // Use macro for fast execution
      nf_read_sector_to_usb(s_nb_sectors_step);                   // read the concerned sectors of the selected page
      status = nf_xfer_update_vars();                             // check if last page or not
   }

   Nf_access_signal_off();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   return CTRL_GOOD;
}

Here is the call graph for this function:

Ctrl_status nf_write_10	(	U32	log_sector,
		U16	n_sectors
	)

This function initializes the Nand Flash for a write operation.

Parameters:

	log_sector	Logical sector address to start read
	nb_sector	Number of sectors to transfer

Returns:

CTRL_GOOD if ok, CTRL_FAIL if read outside memory

Definition at line 381 of file nf_mngt.c.

References CTRL_FAIL, CTRL_GOOD, FALSE, G_CACHE_PROG, G_SHIFT_PAGE_BYTE, Is_nf_2k, LSB0, Nf_access_signal_off, Nf_access_signal_on, NF_CACHE_PROGRAM_CMD, nf_dfc_write_stop(), nf_erase_old_blocks(), nf_get_sectors_number(), nf_open_write(), NF_PAGE_PROGRAM_CMD, NF_TRANS_NORMAL, nf_translate(), nf_update_spare_zone(), nf_write_sector_from_usb(), nf_xfer_update_vars(), nf_XMCR_disable(), nf_XMCR_enable(), NFC_ACT_DEV_SELECT, Nfc_action, Nfc_open_page_write, nfc_open_page_write(), Nfc_set_cmd, S_SHIFT_LOG_BLOCK_SECTOR, S_SHIFT_SECTOR_BYTE, SIZE_BLOCK_PAGE, trace(), trace_hex16(), trace_hex32(), trace_nl(), and TRUE.

{
  U8 status;
  Ctrl_status tmp_bool;

   // Test that the logical sector address is valid
   if ( 0==n_sectors )                                   { return CTRL_GOOD; }
   if ( (log_sector+n_sectors)>nf_get_sectors_number() ) { return CTRL_FAIL; }

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   s_n_sectors       = n_sectors;
   s_curr_log_sector = log_sector;
   s_save_log_addr   = log_sector + n_sectors;
   g_fatal           = FALSE;
   s_mem             = TRUE;
   s_start           = TRUE;

   trace("wr;"); trace_hex32(s_curr_log_sector); trace(";"); trace_hex16(s_n_sectors); trace_nl();
   
   // First write operation
   Nf_access_signal_on();
   if(( s_curr_log_sector==g_last_log_sector )                                           // New write is just after to the last write
   && (!(  ( 0==((U16)g_last_log_sector & ( ((U16)1<<(S_SHIFT_LOG_BLOCK_SECTOR)) -1)))   // Not on a logical block boundary
      && ( g_curr_dev_id==0                                                        ))))
   {
      trace("continue");trace_nl();
      nf_translate( NF_TRANS_NORMAL );
      Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);  // open the current device
      nfc_open_page_write( g_next_phys_page_addr, s_curr_n_byte );
   }
   else
   {      
      nf_open_write( TRUE );
   }
   nf_write_sector_from_usb(s_nb_sectors_step);    // s_nb_sectors_step has been calculated in nf_translate()
   if (Is_nf_2k())
   {
      nf_update_spare_zone((U8)(1<<(G_SHIFT_PAGE_BYTE - S_SHIFT_SECTOR_BYTE))-s_nb_sectors_step, s_nb_sectors_step);    // update the spare zone once the page has been filled in
   }
   else
   {
     nf_update_spare_zone(0, 1);    // update the spare zone once the page has been filled in
   }
   g_last_log_sector  = s_curr_log_sector + s_nb_sectors_step;    // Memorize next logical sector to be managed
   status = nf_xfer_update_vars();

   // Next write operations
   while (status == FALSE)    // exit when operation finished
   {
      if(!(LSB0(g_next_phys_page_addr) & (SIZE_BLOCK_PAGE-1))  // new block
      && (g_curr_dev_id==0                                  )) // on device 0.
      {
         Nfc_set_cmd(NF_PAGE_PROGRAM_CMD); // Program the page
         nf_erase_old_blocks();
         nf_open_write( FALSE );
      }
      else
      {
         if( G_CACHE_PROG )
         {
            Nfc_set_cmd(NF_CACHE_PROGRAM_CMD);
         }else{
            Nfc_set_cmd(NF_PAGE_PROGRAM_CMD);
         }
         Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);
         Nfc_open_page_write( g_next_phys_page_addr, s_curr_n_byte ); // Use macro for fast execution
      }
      nf_write_sector_from_usb(s_nb_sectors_step);
      if (Is_nf_2k())
      {
         nf_update_spare_zone(0, s_nb_sectors_step);
      }
      else
      {
         nf_update_spare_zone(0, 1);    // update the spare zone once the page has been filled in
      }
      g_last_log_sector  = s_curr_log_sector + s_nb_sectors_step;    // Memorize next logical sector to be managed
      status = nf_xfer_update_vars();  // check if last block or not
   }

   tmp_bool = nf_dfc_write_stop(0);   // ends write operations with "nf_dfc_write_stop(0)" that save the current environnement
   Nf_access_signal_off();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   return tmp_bool;
}

Here is the call graph for this function:

Ctrl_status nf_ram_2_nf	(	U32	addr,
		U8 *	ram
	)

This fonction initialise the memory for a write operation from ram buffer.

DATA FLOW is: RAM => NF

(sector = 512B)

Parameters:

	addr	Sector address to write
	ram	Ram buffer pointer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 2114 of file nf_mngt.c.

References FALSE, G_SHIFT_PAGE_BYTE, Is_nf_2k, Nf_access_signal_off, Nf_access_signal_on, nf_dfc_write_stop(), nf_open_write(), NF_TRANS_NORMAL, nf_translate(), nf_update_spare_zone(), Nf_wr_byte, nf_xfer_update_vars(), nf_XMCR_disable(), nf_XMCR_enable(), NFC_ACT_DEV_SELECT, Nfc_action, nfc_open_page_write(), S_SHIFT_LOG_BLOCK_SECTOR, S_SHIFT_SECTOR_BYTE, and TRUE.

{
  Ctrl_status tmp_bool;
  U16 i;

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   s_n_sectors       = 1;
   s_curr_log_sector = addr;
   s_save_log_addr   = addr + 1;
   g_fatal           = FALSE;
   s_mem             = TRUE;
   s_start           = TRUE;

   // First write operation
   Nf_access_signal_on();
   if(( s_curr_log_sector==g_last_log_sector )                                           // New write is just after to the last write
   && (!(  ( 0==((U16)g_last_log_sector & ( ((U16)1<<(S_SHIFT_LOG_BLOCK_SECTOR)) -1)))   // Not on a logical block boundary
      && ( g_curr_dev_id==0                                                        ))))
   {
      nf_translate( NF_TRANS_NORMAL );
      Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);  // open the current device
      nfc_open_page_write( g_next_phys_page_addr, s_curr_n_byte );
   }
   else
   {      
      nf_open_write( TRUE );
   }
   
   for(i=0;i<512;i++)
   {
      Nf_wr_byte(*ram);
      ram++;
   }

   if (Is_nf_2k())
   {
      nf_update_spare_zone((U8)(1<<(G_SHIFT_PAGE_BYTE - S_SHIFT_SECTOR_BYTE))-s_nb_sectors_step, s_nb_sectors_step);    // update the spare zone once the page has been filled in
   }
   else
   {
     nf_update_spare_zone(0, 1);    // update the spare zone once the page has been filled in
   }
   nf_xfer_update_vars();

   tmp_bool = nf_dfc_write_stop(0);   // ends write operations with "nf_dfc_write_stop(0)" that save the current environnement
   Nf_access_signal_off();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   return tmp_bool;
}

Here is the call graph for this function:

Ctrl_status nf_nf_2_ram	(	U32	addr,
		U8 *	ram
	)

This fonction read 1 sector from NF to ram buffer.

DATA FLOW is: NF => RAM

(sector = 512B)

Parameters:

	addr	Sector address to read
	ram	Ram buffer pointer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 2183 of file nf_mngt.c.

References CTRL_GOOD, FALSE, G_SHIFT_PAGE_BYTE, Min, Nf_access_signal_off, Nf_access_signal_on, nf_open_read(), Nf_rd_byte, nf_xfer_update_vars(), nf_XMCR_disable(), nf_XMCR_enable(), NFC_ACT_DEV_SELECT, Nfc_action, nfc_open_page_read(), S_SHIFT_SECTOR_BYTE, and TRUE.

{
  U16 i;

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_enable();
#endif

   s_n_sectors       = 1;
   s_curr_log_sector = addr;
   s_save_log_addr   = addr + 1;
   g_fatal           = FALSE;
   s_mem             = TRUE;
   s_start           = TRUE;

   // First read operation
   Nf_access_signal_on();
   nf_open_read(TRUE);
   Nfc_action(NFC_ACT_DEV_SELECT, g_curr_dev_id);
   nfc_open_page_read( g_phys_page_addr[g_curr_dev_id], s_curr_n_byte );
   s_nb_sectors_step = (U8)                              // determine number of sectors to be read
                       (Min(                             // on this first page
                             1,
                             ((1<<(G_SHIFT_PAGE_BYTE - S_SHIFT_SECTOR_BYTE))-(s_curr_n_byte >> 9))
                           )
                       );
   
   Disable_interrupt();  
   for(i=0;i<512;i++)
   {
      *ram=Nf_rd_byte();
      ram++;
   }
   Enable_interrupt();  
   nf_xfer_update_vars();
   Nf_access_signal_off();

#if (NF_XMCR_MODULE_SHARED == ENABLED)
   nf_XMCR_disable();
#endif

   return CTRL_GOOD;   
}

Here is the call graph for this function:

---

Variable Documentation

_MEM_TYPE_SLOW_ U16 _debug

Definition at line 115 of file nf_mngt.h.

Referenced by nf_cache_fbb_flush(), nf_cache_lut_flush(), nf_check_fbb(), nf_check_lut(), and nf_write_lut().

---