levelx/test/regression/levelx_nand_flash_test.c

/* Basic NOR flash tests...  */

#include <stdio.h>
#include "lx_api.h"

#define     DEMO_STACK_SIZE         4096


/* Define the ThreadX object control blocks...  */
#ifndef LX_STANDALONE_ENABLE
TX_THREAD               thread_0;
#endif
UCHAR                   thread_0_stack[DEMO_STACK_SIZE];

//#define EXTENDED_CACHE
#ifdef EXTENDED_CACHE
UCHAR                   cache_memory[50000];
#endif

/* Define LevelX structures.  */

LX_NAND_FLASH   nand_sim_flash;
ULONG           buffer[2048];
ULONG           readbuffer[2048];

extern ULONG    *nand_flash_memory;

/* Define LevelX NOR flash simulator prototoypes.  */

UINT  _lx_nand_flash_simulator_erase_all(VOID);
UINT  _lx_nand_flash_simulator_initialize(LX_NAND_FLASH *nand_flash);

VOID  _fx_nand_flash_read_sectors(ULONG logical_sector, ULONG sectors, UCHAR *destination_buffer);
VOID  _fx_nand_flash_write_sectors(ULONG logical_sector, ULONG sectors, UCHAR *source_buffer);

#if 0
typedef struct SECTOR_STRUCT
{
    ULONG       words[2048/4];
} SECTOR;

SECTOR  test_write[8];
SECTOR  test_read[8];
#endif

#if 1

UCHAR   byte_buffer[2048];
UCHAR   ecc_bytes[24];
UCHAR   lx_ecc_buffer[24];

#endif

/* Define thread prototypes.  */

void    thread_0_entry(ULONG thread_input);

VOID ComputePageECC(UCHAR *data, INT size, UCHAR *code);
INT  CorrectPageECC(UCHAR *data, INT size, UCHAR *code);



/* Define main entry point.  */

int main()
{
  
    /* Enter the ThreadX kernel.  */
#ifndef LX_STANDALONE_ENABLE
    tx_kernel_enter();
#else
    thread_0_entry(0);
#endif

}


/* Define what the initial system looks like.  */
#ifndef LX_STANDALONE_ENABLE
void    tx_application_define(void *first_unused_memory)
{


    /* Create the main thread.  */
    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0,  
            thread_0_stack, DEMO_STACK_SIZE, 
            1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
}
#endif


#define NAND_MEMORY_SIZE 2056
ULONG nand_memory_space[NAND_MEMORY_SIZE];

/* For random read/write test */
#define MAX_SECTOR_ADDRESS 64000*4
#define SECTOR_SIZE 512

UCHAR local_data_buffer[MAX_SECTOR_ADDRESS * SECTOR_SIZE];

/* Define the test threads.  */

void    thread_0_entry(ULONG thread_input)
{

ULONG   i, j, sector;
UINT    status;

ULONG   *word_ptr;
UCHAR   *byte_ptr;

  
    /* Erase the simulated NOR flash.  */
    _lx_nand_flash_simulator_erase_all();
    
    /* Initialize LevelX.  */
    _lx_nand_flash_initialize();

    /* Test 1: Simple write 520 sectors and read 520 sectors.  */
    printf("Test 1: Simple write-read 520 sectors...........");

    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    status= lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
    while(1)
        {
        }
    }
#ifdef EXTENDED_CACHE
    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    /* Write 520 sectors....  */
    for (i = 0; i < 520; i++)
    {
        for (j = 0; j < 512; j++)
          buffer[j] =  i;
        
        status =  lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    }
    
    /* Close and reopen the flash. */
    lx_nand_flash_close(&nand_sim_flash);

    LX_MEMSET(nand_memory_space, 0, sizeof(nand_memory_space));
    LX_MEMSET(&nand_sim_flash, 0, sizeof(nand_sim_flash));

    status = lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    /* Read back 520 sectors...  */
    for (i = 0; i < 520; i++)
    {
        
        status =  lx_nand_flash_sector_read(&nand_sim_flash, i, buffer);
      
        if (status != LX_SUCCESS)
        {
#ifdef BATCH_TEST
    exit(1);
#endif
          printf("FAILED!\n");
          while(1)
          {
          }
        }
        
        for (j = 0; j < 128; j++)
        {
          
          if (buffer[j] !=  i)
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
        }
    }

    _lx_nand_flash_close(&nand_sim_flash);
    printf("SUCCESS!\n");

    /* Test 2: Write same sector 320 times.  */
    printf("Test 2: Write same sector 320 times.............");
    
    /* Reinitialize...  */    
    _lx_nand_flash_simulator_erase_all();
    
    
    lx_nand_flash_initialize();

    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));


    lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    for (j = 0; j < 512; j++)
         buffer[j] =  0xFFFFFFFF;
    
    /* Write same sector 320 sectors....  */
    for (i = 0; i < 320; i++)
    {
        for (j = 0; j < 512; j++)
          buffer[j] =  i;
      
        if (i == 319)
            buffer[j-1]--;
        status =  lx_nand_flash_sector_write(&nand_sim_flash, 7, buffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
        status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
        for (j = 0; j < 128; j++)
        {
          
          if (buffer[j] !=  readbuffer[j])
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
        }
        
        /* Write other sectors just to have additional sectors to manage.  */
        if (i == 1)
          lx_nand_flash_sector_write(&nand_sim_flash, 1, buffer);
        if (i == 16)
          lx_nand_flash_sector_write(&nand_sim_flash, 16, buffer);
        if (i == 32)
          lx_nand_flash_sector_write(&nand_sim_flash, 32, buffer);
        if (i == 48)
          lx_nand_flash_sector_write(&nand_sim_flash, 48, buffer);
        if (i == 64)
          lx_nand_flash_sector_write(&nand_sim_flash, 64, buffer);
        if (i == 80)
          lx_nand_flash_sector_write(&nand_sim_flash, 80, buffer);
        if (i == 96)
          lx_nand_flash_sector_write(&nand_sim_flash, 96, buffer);
        if (i == 112)
          lx_nand_flash_sector_write(&nand_sim_flash, 112, buffer);
    }

    status =  lx_nand_flash_defragment(&nand_sim_flash);

    
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 319)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 1)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 16)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 32)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 48)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 64)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 80)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 96)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 112)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }

    status =  lx_nand_flash_defragment(&nand_sim_flash);
    
    if (status != LX_NOT_SUPPORTED)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
   
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    printf("SUCCESS!\n");
  
    printf("Test 3: Page copy test..........................");

    /* Reinitialize...  */
    _lx_nand_flash_simulator_erase_all();


    lx_nand_flash_initialize();

    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));


    lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));

    for (j = 0; j < 512; j++)
        buffer[j] = 0xFFFFFFFF;

    status = lx_nand_flash_sector_write(&nand_sim_flash, 0, buffer);

    /* Write same sector 320 sectors....  */
    for (i = 256; i < 512; i++)
    {
        for (j = 0; j < 512; j++)
            buffer[j] = i;

        if (i == 300) continue;

        status = lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);

        if (status != LX_SUCCESS)
        {
            printf("FAILED!\n");
#ifdef BATCH_TEST
            exit(1);
#endif
            while (1)
            {
            }
        }
    }

    status = lx_nand_flash_sector_write(&nand_sim_flash, 300, buffer);
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    status = lx_nand_flash_sector_write(&nand_sim_flash, 400, buffer);
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }
    if (nand_sim_flash.lx_nand_flash_block_status_table[nand_sim_flash.lx_nand_flash_block_mapping_table[1]] & LX_NAND_BLOCK_STATUS_NON_SEQUENTIAL)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }
    
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    printf("SUCCESS!\n");

    printf("Test 4: Random read/write test..................");

    LX_MEMSET(local_data_buffer, 0xff, sizeof(local_data_buffer));

    /* Reinitialize...  */
    _lx_nand_flash_simulator_erase_all();


    lx_nand_flash_initialize();

    status = lx_nand_flash_format(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    status = lx_nand_flash_open(&nand_sim_flash, "sim nand flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
    if (status != LX_SUCCESS)
    {
        printf("FAILED!\n");
#ifdef BATCH_TEST
        exit(1);
#endif
        while (1)
        {
        }
    }

    static ULONG loop_count = 200;
    ULONG operation;
    ULONG sector_number;
    ULONG data_byte;
    ULONG sector_count;
    static ULONG read_count = 0;
    static ULONG write_count = 0;
    static ULONG release_count = 0;
    static ULONG reopen_count = 0;

    while (loop_count--)
    {
        operation = (ULONG)rand() % 32768;
        if (operation < 16384)
        {
            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
            sector_count = ((ULONG)rand() % 768) + 1;
            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
            {
                sector_count = MAX_SECTOR_ADDRESS - sector_number;
            }

            while (sector_count--)
            {
                status = lx_nand_flash_sector_read(&nand_sim_flash, sector_number, readbuffer);
                if (status != LX_SUCCESS)
                {
                    printf("FAILED!\n");
#ifdef BATCH_TEST
                    exit(1);
#endif
                    while (1)
                    {
                    }
                }
#ifdef FULL_SECTOR_DATA_VERIFY
                status = memcmp((local_data_buffer + sector_number * SECTOR_SIZE), readbuffer, SECTOR_SIZE);
#else
                status = *(ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) - readbuffer[0];
#endif
                if (status != 0)
                {
                    printf("FAILED!\n");
#ifdef BATCH_TEST
                    exit(1);
#endif
                    while (1)
                    {
                    }
                }
                read_count++;
                sector_number++;
            }
        }
        else if (operation < 29491)
        {
            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
            sector_count = ((ULONG)rand() % 768) + 1;
            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
            {
                sector_count = MAX_SECTOR_ADDRESS - sector_number;
            }

            while (sector_count--)
            {
                data_byte = (ULONG)rand();

#ifdef FULL_SECTOR_DATA_VERIFY
                LX_MEMSET((local_data_buffer + sector_number * SECTOR_SIZE), data_byte, SECTOR_SIZE);
#else
                *(ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) = data_byte;
#endif
                status = lx_nand_flash_sector_write(&nand_sim_flash, sector_number, local_data_buffer + sector_number * SECTOR_SIZE);
                if (status != LX_SUCCESS)
                {
                    printf("FAILED!\n");
#ifdef BATCH_TEST
                    exit(1);
#endif
                    while (1)
                    {
                    }
                }
                write_count++;
                sector_number++;
            }
        }
        else if(operation < 32760)
        {
            sector_number = ((ULONG)rand() * (ULONG)rand()) % MAX_SECTOR_ADDRESS;
            data_byte = 0xffffffff;
            sector_count = ((ULONG)rand() % 768) + 1;
            if (sector_number + sector_count > MAX_SECTOR_ADDRESS)
            {
                sector_count = MAX_SECTOR_ADDRESS - sector_number;
            }

            while (sector_count--)
            {
                
#ifdef FULL_SECTOR_DATA_VERIFY
                LX_MEMSET((local_data_buffer + sector_number * SECTOR_SIZE), data_byte, SECTOR_SIZE);
#else
                * (ULONG*)(local_data_buffer + sector_number * SECTOR_SIZE) = data_byte;
#endif
                status = lx_nand_flash_sector_release(&nand_sim_flash, sector_number);
                if (status != LX_SUCCESS)
                {
                    printf("FAILED!\n");
#ifdef BATCH_TEST
                    exit(1);
#endif
                    while (1)
                    {
                    }
                }
                release_count++;
                sector_number++;
            }
        }
        else
        {
            /* Close and reopen the flash. */
            status = lx_nand_flash_close(&nand_sim_flash);
            if (status != LX_SUCCESS)
            {
                printf("FAILED!\n");
#ifdef BATCH_TEST
                exit(1);
#endif
                while (1)
                {
                }
            }

            status = lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
            if (status != LX_SUCCESS)
            {
                printf("FAILED!\n");
#ifdef BATCH_TEST
                exit(1);
#endif
                while (1)
                {
                }
            }
            reopen_count++;
        }
    }

    printf("SUCCESS!\n");

#if 0
    /* Point at the simulated NOR flash memory.  */
    word_ptr =  nand_flash_memory;
    
   
    /* Test 3: Corrupt block 0, simulate a power interruption during erase of block 0, 
       after the erase, but before the erase count is setup.  */
    printf("Test 3: Block erase-initialize interrupted......");
    word_ptr[0] =  0xFFFFFFFF;
    word_ptr[3] =  0x00000000;  /* This simulates a non-erased block.  */

    /* Open the flash and see if we recover properly.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if ((status != LX_SUCCESS) ||
        (nand_sim_flash.lx_nand_flash_free_pages != 111) ||
        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }

   
    /* Corrupt block 0, simulate a power interruption after erase of block 0, 
       but before erase count is setup.  */
    word_ptr[0] =  0xFFFFFFFF;

    /* Open the flash and see if we recover properly.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if ((status != LX_SUCCESS) ||
        (nand_sim_flash.lx_nand_flash_free_pages != 111) ||
        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }

    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    printf("SUCCESS!\n");


    /* Test 4: simulate a power interruption while a new page is being setup.  */
    printf("Test 4: Power interrupted new page setup........");
    
    /* Partially setup new page.  */
    byte_ptr =  (UCHAR *) word_ptr;
    byte_ptr[2053] = 0xBF;      /* Set block 0/page 0 extra bytes to indicate block not empty.  */
    word_ptr[528] =  0x60;

    /* Open the flash and see if we recover properly.  We should mark this page as obsolete. */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if ((status != LX_SUCCESS) ||
        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }


    /* Simulate a power interruption after a new sector is allocated, after data
       had been copied, and the superceeded bit is clear, but before the new entry can be
       setup.  */
       
    /* Copy data block and reset spare.  */
    byte_ptr[2053] = 0xBF;          /* Set block 0/page 0 extra bytes to indicate block not empty.  */
    for (i = 1; i < 512; i++)       /* Fill block 0, page 1 data  */
        word_ptr[i+528] = 0x60; 
    word_ptr[i+528] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
    word_ptr[i+529] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */ 
    
    /* Set the superceded bit in block 1/page 1.   */
    byte_ptr[37957] = 0x80;
    
    /* Open the flash and see if we recover properly.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if ((status != LX_SUCCESS) ||
        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }

    lx_nand_flash_close(&nand_sim_flash);

    /* Simulate a power interruption after a new sector is allocated, after data
       had been copied, and the superceeded bit is clear, the new entry is setup, but the old entry
       has not been invalidated.  */
    byte_ptr[2053] = 0xBF;          /* Set block 0/page 0 extra bytes to indicate block not empty.  */
    for (i = 1; i < 512; i++)       /* Fill block 0, page 1 data  */
        word_ptr[i+528] = 0x60;     
    word_ptr[i+528] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
    word_ptr[i+529] =  0xFFFFFFFF;  /* Reset extra bytes for block 0, page 1 */
    
    byte_ptr =  (UCHAR *) word_ptr;

    /* set the spare info in the new page.  */
    byte_ptr[4162] = 0x60;          /* Setup extra bytes for block 0, page 1  */
    byte_ptr[4163] = 0;             /* Setup extra bytes for block 0, page 1  */
    byte_ptr[4164] = 0;             /* Setup extra bytes for block 0, page 1  */
    byte_ptr[4165] = 0xC0;          /* Setup extra bytes for block 0, page 1  */

    /* Set the superceded bit in block 1/page 1.   */
    byte_ptr[37957] = 0x80;

    /* Open the flash and see if we recover properly.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if ((status != LX_SUCCESS) ||
        (nand_sim_flash.lx_nand_flash_free_pages != 110) ||
        (nand_sim_flash.lx_nand_flash_mapped_pages != 9))
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }

    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 119)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 1)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 16)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 32)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 48)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 64)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 80)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 96)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 112)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }

    status =  lx_nand_flash_defragment(&nand_sim_flash);
    
    if (status != LX_NOT_SUPPORTED)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    
   
    status =  lx_nand_flash_defragment(&nand_sim_flash);
    
    if (status != LX_NOT_SUPPORTED)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 119)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 1)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
     status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 16)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 32)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 48)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 64)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 80)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 96)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 112)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }

    /* Read in reverse order to see if caching helps!  */
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 112, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 112)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 96, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 96)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
     status =  lx_nand_flash_sector_read(&nand_sim_flash, 80, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 80)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 64, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 64)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 48, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 48)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 32, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 32)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 16, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 16)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 1, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 1)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_read(&nand_sim_flash, 7, readbuffer);
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        if (readbuffer[0] != 119)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
    status =  lx_nand_flash_sector_release(&nand_sim_flash, 7);
    if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    status =  lx_nand_flash_sector_release(&nand_sim_flash, 8);
    if (status != LX_SECTOR_NOT_FOUND)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
    status =  lx_nand_flash_defragment(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }

    status =  lx_nand_flash_close(&nand_sim_flash);

    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
   
    printf("SUCCESS!\n");
#endif
#if 0
    printf("Test 5: Random write/read sector................");

    /* Erase the simulated NOR flash.  */
    _lx_nand_flash_simulator_erase_all();

    /* Open the flash.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize, nand_memory_space, sizeof(nand_memory_space));
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if (status != LX_SUCCESS) 
    {
      
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    
    /* Write 100 sectors....  */
    for (i = 0; i < 100; i++)
    {
        for (j = 0; j < 512; j++)
          buffer[j] =  i;
        
        status =  lx_nand_flash_sector_write(&nand_sim_flash, i, buffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    }
    
    /* Read back 100 sectors...  */
    for (i = 0; i < 100; i++)
    {
        
        status =  lx_nand_flash_sector_read(&nand_sim_flash, i, buffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
        for (j = 0; j < 512; j++)
        {
          
          if (buffer[j] !=  i)
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
        }
    }
    
    /* Now, perform 1000 sector writes to randomly selected sectors, each time
       reading first to make sure the previous contents are valid.  */
    for (i = 0; i < 1000; i++)
    {
    
        /* Pickup random sector.  */
        sector =  (rand() % 100);

        /* Read that sector.  */
        status =  lx_nand_flash_sector_read(&nand_sim_flash, sector, buffer);
      
        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
        
        for (j = 0; j < 512; j++)
        {
          
          if ((buffer[j] & 0x0000FFFF) !=  sector)
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
        }

        /* Include the itteraction in the buffer to generate a new write.  */
        for (j = 0; j < 512; j++)
        {
 
            buffer[j] =  (buffer[j] & 0x0000FFFF) | (i << 16);
        }
        
        status =  lx_nand_flash_sector_write(&nand_sim_flash, sector, buffer);

        if (status != LX_SUCCESS)
        {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
        }
    }
    
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
    }
    printf("SUCCESS!\n");
#endif
    
#if 0
    
  for (i = 0; i < 256; i++)
  {
  
      /* Setup buffer.  */
      for (j = 0; j < 2048; j++)
          byte_buffer[j] =  (UCHAR) (rand() % 256);
      
      /* Call the ECC calculate routine.  */
      ComputePageECC(byte_buffer, 2048, ecc_bytes);
      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
      if (status != 0)
      {
        
          /* Check for corrected return value.  */
          if (status != 1)
          {
            while(1)
            {
            }
          }
      }
      
      /* Call LevelX ECC routines to do the same thing.  */
      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
          printf("FAILED!\n");
          while(1)
          {
          }
      }

//      ComputePageECC(byte_buffer, 2048, ecc_bytes);

      
      /* Determine if there is any difference between the original and the new ECC routine.  */
      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
          (ecc_bytes[11] != lx_ecc_buffer[11]))
      {
         while(1)
         {
         }
      }

      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
        
          /* Is it the corrected status?  */
          if (status !=  LX_NAND_ERROR_CORRECTED)
          {
            printf("FAILED!\n");
            while(1)
            {
            }
          }
      }
  }
#endif

#if 0  
  for (i = 0; i < 256; i++)
  {
  
      /* Setup buffer.  */
      for (j = 0; j < 2048; j++)
          byte_buffer[j] =  (UCHAR) (rand() % 256);
      
      /* Call the ECC calculate routine.  */
      ComputePageECC(byte_buffer, 2048, ecc_bytes);
      
      /* Corrupt a bit in each 256 byte page.  */
      if (byte_buffer[7] & 1)
          byte_buffer[7] =  byte_buffer[7] & 0xFE;
      else
          byte_buffer[7] =  byte_buffer[7] | 1;
 
      if (byte_buffer[277] & 1)
          byte_buffer[277] =  byte_buffer[277] & 0xFE;
      else
          byte_buffer[277] =  byte_buffer[277] | 1;

      if (byte_buffer[577] & 1)
          byte_buffer[577] =  byte_buffer[577] & 0xFE;
      else
          byte_buffer[577] =  byte_buffer[577] | 1;
      
      if (byte_buffer[777] & 1)
          byte_buffer[777] =  byte_buffer[777] & 0xFE;
      else
          byte_buffer[777] =  byte_buffer[777] | 1;
      
      if (byte_buffer[1077] & 1)
          byte_buffer[1077] =  byte_buffer[1077] & 0xFE;
      else
          byte_buffer[1077] =  byte_buffer[1077] | 1;

      if (byte_buffer[1297] & 1)
          byte_buffer[1297] =  byte_buffer[1297] & 0xFE;
      else
          byte_buffer[1297] =  byte_buffer[1297] | 1;
      
      if (byte_buffer[1636] & 1)
          byte_buffer[1636] =  byte_buffer[1636] & 0xFE;
      else
          byte_buffer[1636] =  byte_buffer[1636] | 1;

      if (byte_buffer[1892] & 1)
          byte_buffer[1892] =  byte_buffer[1892] & 0xFE;
      else
          byte_buffer[1892] =  byte_buffer[1892] | 1;
     
      
      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
      if (status != 0)
      {
        
          /* Check for corrected return value.  */
          if (status != 1)
          {
            while(1)
            {
            }
          }
      }
      
      /* Call LevelX ECC routines to do the same thing.  */
      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
          printf("FAILED!\n");
          while(1)
          {
          }
      }


      
      /* Determine if there is any difference between the original and the new ECC routine.  */
      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
          (ecc_bytes[11] != lx_ecc_buffer[11]))
      {
         while(1)
         {
         }
      }

      /* Corrupt a bit in each 256 byte page.  */
      if (byte_buffer[7] & 1)
          byte_buffer[7] =  byte_buffer[7] & 0xFE;
      else
          byte_buffer[7] =  byte_buffer[7] | 1;
 
      if (byte_buffer[277] & 1)
          byte_buffer[277] =  byte_buffer[277] & 0xFE;
      else
          byte_buffer[277] =  byte_buffer[277] | 1;

      if (byte_buffer[577] & 1)
          byte_buffer[577] =  byte_buffer[577] & 0xFE;
      else
          byte_buffer[577] =  byte_buffer[577] | 1;
      
      if (byte_buffer[777] & 1)
          byte_buffer[777] =  byte_buffer[777] & 0xFE;
      else
          byte_buffer[777] =  byte_buffer[777] | 1;
      
      if (byte_buffer[1077] & 1)
          byte_buffer[1077] =  byte_buffer[1077] & 0xFE;
      else
          byte_buffer[1077] =  byte_buffer[1077] | 1;

      if (byte_buffer[1297] & 1)
          byte_buffer[1297] =  byte_buffer[1297] & 0xFE;
      else
          byte_buffer[1297] =  byte_buffer[1297] | 1;
      
      if (byte_buffer[1636] & 1)
          byte_buffer[1636] =  byte_buffer[1636] & 0xFE;
      else
          byte_buffer[1636] =  byte_buffer[1636] | 1;

      if (byte_buffer[1892] & 1)
          byte_buffer[1892] =  byte_buffer[1892] & 0xFE;
      else
          byte_buffer[1892] =  byte_buffer[1892] | 1;
      
      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
        
          /* Is it the corrected status?  */
          if (status !=  LX_NAND_ERROR_CORRECTED)
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
      }

      /* Call LevelX ECC routines to create the ECC over the corrected buffer.  */
      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
      }

  }



#endif
    
#if 0  

  /* Corrupting ECC code is detected and returns a failure... this test is not valid!  */

  for (i = 0; i < 256; i++)
  {
  
      /* Setup buffer.  */
      for (j = 0; j < 2048; j++)
          byte_buffer[j] =  (UCHAR) (rand() % 256);
      
      /* Call the ECC calculate routine.  */
      ComputePageECC(byte_buffer, 2048, ecc_bytes);
      
      
      /* Call LevelX ECC routines to do the same thing.  */
      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
          printf("FAILED!\n");
          while(1)
          {
          }
      }

      /* Determine if there is any difference between the original and the new ECC routine.  */
      if ((ecc_bytes[0] != lx_ecc_buffer[0]) || 
          (ecc_bytes[1] != lx_ecc_buffer[1]) ||
          (ecc_bytes[2] != lx_ecc_buffer[2]) ||
          (ecc_bytes[3] != lx_ecc_buffer[3]) ||
          (ecc_bytes[4] != lx_ecc_buffer[4]) ||
          (ecc_bytes[5] != lx_ecc_buffer[5]) ||
          (ecc_bytes[6] != lx_ecc_buffer[6]) ||
          (ecc_bytes[7] != lx_ecc_buffer[7]) ||  
          (ecc_bytes[8] != lx_ecc_buffer[8]) ||  
          (ecc_bytes[9] != lx_ecc_buffer[9]) ||
          (ecc_bytes[10] != lx_ecc_buffer[10]) ||
          (ecc_bytes[11] != lx_ecc_buffer[11]))
      {
         while(1)
         {
         }
      }

      /* Corrupt a bit in each ECC for 256 byte page.  */
      if (ecc_bytes[1] & 1)
          ecc_bytes[1] =  ecc_bytes[1] & 0xFE;
      else
          ecc_bytes[1] =  ecc_bytes[1] | 1;
 
      if (ecc_bytes[4] & 1)
          ecc_bytes[4] =  ecc_bytes[4] & 0xFE;
      else
          ecc_bytes[4] =  ecc_bytes[4] | 1;

      if (ecc_bytes[7] & 1)
          ecc_bytes[7] =  ecc_bytes[7] & 0xFE;
      else
          ecc_bytes[7] =  ecc_bytes[7] | 1;
      
      if (ecc_bytes[10] & 1)
          ecc_bytes[10] =  ecc_bytes[10] & 0xFE;
      else
          ecc_bytes[10] =  ecc_bytes[10] | 1;
      
      if (ecc_bytes[13] & 1)
          ecc_bytes[13] =  ecc_bytes[13] & 0xFE;
      else
          ecc_bytes[13] =  ecc_bytes[13] | 1;

      if (ecc_bytes[16] & 1)
          ecc_bytes[16] =  ecc_bytes[16] & 0xFE;
      else
          ecc_bytes[16] =  ecc_bytes[16] | 1;
      
      if (ecc_bytes[19] & 1)
          ecc_bytes[19] =  ecc_bytes[19] & 0xFE;
      else
          ecc_bytes[19] =  ecc_bytes[19] | 1;

      if (ecc_bytes[22] & 1)
          ecc_bytes[22] =  ecc_bytes[22] & 0xFE;
      else
          ecc_bytes[22] =  ecc_bytes[22] | 1;
     
      
      status =  (UINT) CorrectPageECC(byte_buffer, 2048, ecc_bytes);
      if (status != 0)
      {
        
          /* Check for corrected return value.  */
          if (status != 1)
          {
            while(1)
            {
            }
          }
      }

      /* Corrupt a bit in each ECC for 256 byte page.  */
      if (lx_ecc_buffer[1] & 1)
          lx_ecc_buffer[1] =  lx_ecc_buffer[1] & 0xFE;
      else
          lx_ecc_buffer[1] =  lx_ecc_buffer[1] | 1;
 
      if (lx_ecc_buffer[4] & 1)
          lx_ecc_buffer[4] =  lx_ecc_buffer[4] & 0xFE;
      else
          lx_ecc_buffer[4] =  lx_ecc_buffer[4] | 1;

      if (lx_ecc_buffer[7] & 1)
          lx_ecc_buffer[7] =  lx_ecc_buffer[7] & 0xFE;
      else
          lx_ecc_buffer[7] =  lx_ecc_buffer[7] | 1;
      
      if (lx_ecc_buffer[10] & 1)
          lx_ecc_buffer[10] =  lx_ecc_buffer[10] & 0xFE;
      else
          lx_ecc_buffer[10] =  lx_ecc_buffer[10] | 1;
      
      if (lx_ecc_buffer[13] & 1)
          lx_ecc_buffer[13] =  lx_ecc_buffer[13] & 0xFE;
      else
          lx_ecc_buffer[13] =  lx_ecc_buffer[13] | 1;

      if (lx_ecc_buffer[16] & 1)
          lx_ecc_buffer[16] =  lx_ecc_buffer[16] & 0xFE;
      else
          lx_ecc_buffer[16] =  lx_ecc_buffer[16] | 1;
      
      if (lx_ecc_buffer[19] & 1)
          lx_ecc_buffer[19] =  lx_ecc_buffer[19] & 0xFE;
      else
          lx_ecc_buffer[19] =  lx_ecc_buffer[19] | 1;

      if (lx_ecc_buffer[22] & 1)
          lx_ecc_buffer[22] =  lx_ecc_buffer[22] & 0xFE;
      else
          lx_ecc_buffer[22] =  lx_ecc_buffer[22] | 1;
     

      
      status =  lx_nand_flash_page_ecc_check(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
        
          /* Is it the corrected status?  */
          if (status !=  LX_NAND_ERROR_CORRECTED)
          {
            printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
            while(1)
            {
            }
          }
      }

      /* Call LevelX ECC routines to create the ECC over the corrected buffer.  */
      status =  lx_nand_flash_page_ecc_compute(&nand_sim_flash, byte_buffer, lx_ecc_buffer);

      if (status != LX_SUCCESS)
      {
          printf("FAILED!\n");
#ifdef BATCH_TEST
    exit(1);
#endif
          while(1)
          {
          }
      }

  }



#endif
 
  
    
#if 0
/* TEST FileX packing routines.  */

    /* Erase the simulated NAND flash.  */
    _lx_nand_flash_simulator_erase_all();

    /* Open the flash.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize);
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if (status != LX_SUCCESS) 
    {
      
          printf("FAILED!\n");
          while(1)
          {
          }
    }

  /* Setup the write data.  */
  for (i = 0; i < 8; i++)
  {
      for (j = 0; j < 512/4; j++)
        test_write[i].words[j] = i;
  }

  /* Now write the data one logical sector at a time.  */
  for (i = 0; i < 8; i++)
  {
       _fx_nand_flash_write_sectors(i, 1, (UCHAR *) &test_write[i]);
  }

  /* Setup the read buffer.  */
  for (i = 0; i < 8; i++)
  {
      for (j = 0; j < 512/4; j++)
        test_read[i].words[j] = 0xEFEFEFEF;
  }

  /* Read back in one sector at a time.  */
  for (i = 0; i < 8; i++)
  {
       _fx_nand_flash_read_sectors(i, 1, (UCHAR *) &test_read[i].words[0]);
  }
  
  /* Setup the read buffer.  */
  for (i = 0; i < 8; i++)
  {
      for (j = 0; j < 512/4; j++)
        test_read[i].words[j] = 0xEFEFEFEF;
  }

  _fx_nand_flash_read_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);
  _fx_nand_flash_read_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
  _fx_nand_flash_read_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);

  /* Setup the read buffer.  */
  for (i = 0; i < 8; i++)
  {
      for (j = 0; j < 512/4; j++)
        test_read[i].words[j] = 0xEFEFEFEF;
  }

  _fx_nand_flash_read_sectors(0, 8, (UCHAR *) &test_read[0].words[0]);

  
    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
          while(1)
          {
          }
    }

    /* Erase the simulated NAND flash.  */
    _lx_nand_flash_simulator_erase_all();

    /* Open the flash.  */    
    status =  lx_nand_flash_open(&nand_sim_flash, "sim nor flash", _lx_nand_flash_simulator_initialize);
#ifdef EXTENDED_CACHE
    status += lx_nand_flash_extended_cache_enable(&nand_sim_flash, cache_memory, sizeof(cache_memory));
#endif
    
    if (status != LX_SUCCESS) 
    {
      
          printf("FAILED!\n");
          while(1)
          {
          }
    }

    _fx_nand_flash_write_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);
    _fx_nand_flash_write_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
    _fx_nand_flash_write_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);

    /* Setup the read buffer.  */
    for (i = 0; i < 8; i++)
    {
      for (j = 0; j < 512/4; j++)
          test_read[i].words[j] = 0xEFEFEFEF;
    }

    _fx_nand_flash_read_sectors(0, 1, (UCHAR *) &test_read[0].words[0]);
    _fx_nand_flash_read_sectors(1, 2, (UCHAR *) &test_read[1].words[0]);
    _fx_nand_flash_read_sectors(3, 5, (UCHAR *) &test_read[3].words[0]);

    status =  lx_nand_flash_close(&nand_sim_flash);
    
    if (status != LX_SUCCESS)
    {
          printf("FAILED!\n");
          while(1)
          {
          }
    }

  /* End */    
#endif    
    
#ifdef BATCH_TEST
    exit(0);
#endif
     /* All done!  */
     while(1)
     {
     }
}