#include "pi_util.h"
#include "ecc/pi_ecc.h"

/* local functions, defs */
#define BIT_FLIP(_val,_posn) ((_val)^(1<<(_posn)))
#define BIT_FLIP2(_val,_posn1,_posn2) (((_val)^(1<<(_posn1)))^(1<<(_posn2)))
#define CLIP(_val,_l,_u)     ((_val)<(_l)?(_l):((_val)>(_u)?(_u):(_val)))
#define RAND_BIT_0_21        ( ((rand()&0x1f)*21+(21/2)) /31 )

void pageRandEcc(u8 *buf);
int sberrReturnCheck(int ret,u8 *expected,u8 *actual,
                        int indxStart,int bytes);
int sberrEccReturnCheck(int ret,u8 *expected,u8 *actual,
                        int indxStart,int bytes);
int piEccGen(int cycles,int device,int bigDevice);
void pageRandEcc(u8 *buf);
int piEccReadNoErr(int cycles,int device,int bigDevice);
int piEccSingleBitErrWalk(int device,int bigDevice);
int piEccSingleBitErrHalf(int device,int bigDevice);
void setFlipLocations(u8 *bitErrorLoc,int *bitFlipLocations);
void flipPiBufBits(int piBuf,int *bitFlipLocations,u8 *buf);
void unflipPiBufBits(int piBuf,int *bitFlipLocations,u8 *buf);
int dberrReturnCheck(int ret);
int piEccDoubleBitErr(int device,int bigDevice,int numCycles,
                      u8 *bitErrorLoc,int enableInt,int secondHalfOnlyRead);


int sberrReturnCheck(int ret,u8 *expected,u8 *actual,int indxStart,int bytes)
{
    int k;

    if(ret==DRIVER_ERROR){
        return TESTERROR;
    }
    else if(ret!=DRIVER_ECC_SGL_BITERR){
        _TRACE(DERROR, fprintf(LogFp,
                  "  page read result not DRIVER_ECC_SGL_BITERR.\n"
                  "  instead, was %d\n\n"
                  "  bytes bad list:\n",ret));
        for(k=0;k<528;k++){
            if(expected[k]!=actual[k]){
                _TRACE(DERROR, fprintf(LogFp,"    %d\n",k));
            }
        }
        return FAIL;
    }

    /* check data matches */
    for(k=indxStart;k<indxStart+bytes;k++){
        if(expected[k]!=actual[k]){
            _TRACE(DERROR, fprintf(LogFp,
                   "  bad byte %d: expect %d, actual %d\n",
                   k,expected[k],actual[k]));
            return FAIL;
        }
    }

    return PASS;
}

int sberrEccReturnCheck(int ret,u8 *expected,u8 *actual,
                        int indxStart,int bytes)
{
    int k;

    if(ret==DRIVER_ERROR){
        return TESTERROR;
    }
    else if(ret!=DRIVER_ECC_SGL_BITERR){
        _TRACE(DERROR, fprintf(LogFp,
                  "  page read result not DRIVER_ECC_SGL_BITERR.\n"
                  "  instead, was %d\n\n"
                  "  bytes bad list:\n",ret));
        for(k=0;k<528;k++){
            if(expected[k]!=actual[k]){
                _TRACE(DERROR, fprintf(LogFp,"    %d\n",k));
            }
        }
        return FAIL;
    }

    /* check data matches (ecc bits don't get corrected) */
    for(k=indxStart;k<indxStart+bytes;k++){
        if( k<PI_FLASH_PAGE_ECC2_OFFSET && k>(PI_FLASH_PAGE_ECC2_OFFSET+2) &&
            k<PI_FLASH_PAGE_ECC1_OFFSET && k>(PI_FLASH_PAGE_ECC1_OFFSET+2) &&
            expected[k]!=actual[k]){
            _TRACE(DERROR, fprintf(LogFp,
                                   "  bad byte %d: expect %d, actual %d\n",
                                   k,expected[k],actual[k]));
            return FAIL;
        }
    }

    return PASS;
}


/* cycles: how many random patterns to run.
 * This will toggle buffers as it goes.
 *
 * checks int generation on program (with ecc on).
 * every other program has ints enabled.
 */
int piEccGen(int cycles,int device,int bigDevice)
{
    int i,j,ret;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    TOGGLE_INIT;

    for(j=0;j<cycles;j++){
        if((j&0x1f) == 0){
            /* erase block 0 */
            _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
            ret = eraseBlock(0,device,0,0,bigDevice,0);
            FLASH_PROG_ERASE_FAIL_RETURN(ret);
        }

        _TRACE(DSTATUS, fprintf(LogFp,"   page %d\n ",j));
        /*
         * write test data to buffer and program
         */
        for(i=0;i<PI_FLASH_PAGE_DATA_SIZE;i++){
            buf[i]=rand();
        }
        for(i=PI_FLASH_PAGE_DATA_SIZE;i<PI_FLASH_PAGE_FULL_SIZE;i++){
            buf[i] = 0xff;
        }
        TOGGLE;
        /* generate ecc on program */
        ret = programFullPage(j<<9,TOGGLE_VAL,
                              device,1,buf,buf+PI_FLASH_PAGE_DATA_SIZE,
                              TOGGLE_VAL,bigDevice,TOGGLE_VAL);
        FLASH_PROG_ERASE_FAIL_RETURN(ret);

        /*
         * read back programmed page into buffer
         */
        ret = readFullPage(TOGGLE_VAL,device,
                           j<<9,0,bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                           bigDevice,0);
        if(ret<0){
            return TESTERROR;
        }
        calculate_ecc(buf,buf+PI_FLASH_PAGE_ECC1_OFFSET);
        calculate_ecc(buf+PI_FLASH_PAGE_DATA_SIZE/2,
                      buf+PI_FLASH_PAGE_ECC2_OFFSET);
        for(i=0;i<PI_FLASH_PAGE_FULL_SIZE;i++){
            if(buf[i]!=bufback[i]){
                return FAIL;
            }
        }
    }
    return PASS;
}


void pageRandEcc(u8 *buf)
{
    int i;

    for(i=0;i<PI_FLASH_PAGE_DATA_SIZE;i++){
        buf[i]=rand();
    }
    for(i=PI_FLASH_PAGE_DATA_SIZE;i<PI_FLASH_PAGE_FULL_SIZE;i++){
        buf[i] = 0xff;
    }
    calculate_ecc(buf,buf+PI_FLASH_PAGE_ECC1_OFFSET);
    calculate_ecc(buf+PI_FLASH_PAGE_DATA_SIZE/2,
                  buf+PI_FLASH_PAGE_ECC2_OFFSET);
}


int piEccReadNoErr(int cycles,int device,int bigDevice)
{
    int i,j,ret;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    TOGGLE_INIT;
    int intm = 0;  /* start with int mask bit clr */
    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_FLASH);

    for(j=0;j<cycles;j++){
        if(!(j%3)) intm=!intm, toggleFlashIntMask(intm);
        if((j&0x1f) == 0){
            /* erase block 0 */
            _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
            ret = eraseBlock(0,device,0,0,bigDevice,0);
            FLASH_PROG_ERASE_FAIL_RETURN(ret);
        }

        _TRACE(DSTATUS, fprintf(LogFp,"   page %d\n ",j));
        /*
         * write test data to buffer and program
         */
        pageRandEcc(buf);

        /* don't generate ecc on program */
        ret = programFullPage(j<<9,TOGGLE,
                              device,0,buf,buf+PI_FLASH_PAGE_DATA_SIZE,
                              TOGGLE_VAL,bigDevice,0);
        FLASH_PROG_ERASE_FAIL_RETURN(ret);

        /*
         * read back programmed page into buffer. Turn
         * on int every other cycle.  Toggle int mask
         * every 3 cycles.
         */
        ret = readFullPage(TOGGLE,device,j<<9,1,bufback,
                           bufback+PI_FLASH_PAGE_DATA_SIZE,
                           bigDevice,j&1);
        if((j&1) && (flashCheckClearIntr()!=PASS)){
            return FAIL;
        }
        if(!(j&1) && (flashCheckNoIntr()!=PASS)){
            return FAIL;
        }
        if(ret==DRIVER_ERROR){
            return TESTERROR;
        }
        else if(ret!=DRIVER_ECC_NO_ACTION){
            return FAIL;
        }
        for(i=0;i<PI_FLASH_PAGE_FULL_SIZE;i++){
            if(buf[i]!=bufback[i]){
                return FAIL;
            }
        }

        /*
         * repeat for second half only
         */
        TOGGLE;
        /* must zero out buffer reading into, since both now hold
         * the correct data.
         */
        for(i=0;i<PI_FLASH_PAGE_FULL_SIZE;i++){
            bufback[i]=0;
        }
        ioWriteBuffer(bufback,PI_FLASH_PAGE_DATA_SIZE/2,
                      PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE);
        ioWriteBuffer(bufback,PI_FLASH_OOB_SIZE,
                      PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE);
        ret = readSecondHalfPage(TOGGLE_VAL,device,j<<9,1,
                                 bufback+PI_FLASH_PAGE_DATA_SIZE/2,
                                 bufback+PI_FLASH_PAGE_DATA_SIZE,
                                 bigDevice,0);
        if(ret==DRIVER_ERROR){
            return TESTERROR;
        }
        else if(ret!=DRIVER_ECC_NO_ACTION){
            return FAIL;
        }
        for(i=PI_FLASH_PAGE_DATA_SIZE/2;i<PI_FLASH_PAGE_FULL_SIZE;i++){
            if(buf[i]!=bufback[i]){
                return FAIL;
            }
        }

    }
    return PASS;
}


/*
 * Simple test to sanity-check flash controller and ECC hardware
 * for gate-level DV. 
 *
 * This code extracts a single case from the function 
 * piEccSingleBitErrWalk(), below, so uses the same basic flow. 
 * Parameters are hard-coded, but since this is just a sanity 
 * check it is acceptable.
 */
int translateEraseProgRetCode(int ret)
{
    FLASH_PROG_ERASE_FAIL_RETURN(ret);
    return PASS;
}
void eccSingleBitGateLevel(int device,int bigDevice)
{
    int i,j,pageCount,bitToFlip,ret=FAIL;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    u32 *p32_1,*p32_2,bufAddr,bufOobAddr;

    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_FLASH);

    _TRACE(DLOG, fprintf(LogFp,"Running gate-levl flash/ecc Test.\n"));
    fflush(NULL);

    /* fill local "page" with randoms and correct ecc */
    pageRandEcc(buf);

    /* erase block 0 */
    _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
    ret = eraseBlock(0,device,0,0,bigDevice,0);
    ret = translateEraseProgRetCode(ret);
    if( ret != PASS)
        goto report_result;

    bufAddr = PI_BUFFER_0_START;
    
    /* transfer data to pi buffer */
    ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
    ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                  PI_BUFFER_0_OOB_START);

    p32_1=(u32 *)buf;
    p32_2=(u32 *)(buf+PI_FLASH_PAGE_DATA_SIZE/2);
    bitToFlip = 3;
    pageCount = 7;

    /* flip bits and write word to pi buffer */
    IO_WRITE(bufAddr,BIT_FLIP(H2BE4(*p32_1),bitToFlip));
    IO_WRITE(bufAddr+PI_FLASH_PAGE_DATA_SIZE/2,
             BIT_FLIP(H2BE4(*p32_2),bitToFlip));

    /* program page */
    ret = programFullPage(pageCount<<9,
                          0 /* pi buffer for data */,
                          device,0,NULL,NULL,
                          1 /* pi buffer for status read-back */,
                          bigDevice,0);
    ret = translateEraseProgRetCode(ret);
    if( ret != PASS)
        goto report_result;
    
    /* read-back page */
    ret = readFullPage(1 /* pi buffer to read data into */,
                       device,pageCount<<9,1,
                       bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                       bigDevice,0);
    
    /* insure no int generated */
    if(flashCheckNoIntr()!=PASS){
        _TRACE(DERROR, fprintf(LogFp,"spurios int generated\n"));
        ret = FAIL;
        goto report_result;
    }
    
    /* check return from read page and data match */
    if(ret = sberrReturnCheck(ret,buf,bufback,0,
                              PI_FLASH_PAGE_FULL_SIZE)
       != PASS){
        goto report_result;
    }
    
 report_result:
    printf("eccSingleBitGateLevel ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);
}



/*
 * also insures int not generated when ecc is on and
 * int not armed.
 */
int piEccSingleBitErrWalk(int device,int bigDevice)
{
    int i,j,k,pageCount,bitToFlip,byteCover,ret;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    u32 *p32_1,*p32_2,val32,bufAddr,bufOobAddr;
    TOGGLE_INIT;
    int intm = 0; /* start with int mask bit clr */
    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_FLASH);

    /* random buffer initial usage */
    if(rand()&1)
        TOGGLE;

    /* fill page with randoms and correct ecc */
    pageRandEcc(buf);

    /* erase block 0 */
    _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
    ret = eraseBlock(0,device,0,0,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
    
    /* transfer data to pi buffer */
    ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
    ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                  PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE);

    _TRACE(DSTATUS, fprintf(LogFp," walking error bit:\n"));
    pageCount = 0;
    byteCover = 0;
    for( p32_1=(u32 *)buf, p32_2=(u32 *)(buf+PI_FLASH_PAGE_DATA_SIZE/2), j=0;
         j<PI_FLASH_PAGE_DATA_SIZE/2;
         p32_1++, p32_2++, j+=4){

        /* for efficiency, an error is placed in both data halves */

        /* choose random bit in each byte of  word, but first insure
         * all 8 bit positions are tested
         */
        for(i=0;i<32;i+=8){
            if(!(i%3)) intm=!intm, toggleFlashIntMask(intm);
            if(byteCover<8){
                bitToFlip = i + (byteCover++);
            }
            else{
                bitToFlip = i + (rand()&7);
            }
            _TRACE(DSTATUS, fprintf(LogFp," %d\n",bitToFlip+8*j));

            if(pageCount == PI_FLASH_PAGES_PER_BLOCK){
                pageCount = 0;

                /* convenient time to toggle for buffer coverage test */
                TOGGLE;
                bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
                
                /* transfer data to pi buffer */
                ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
                ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                              PI_BUFFER_0_OOB_START+
                              TOGGLE_VAL*PI_FLASH_OOB_SIZE);

                /* erase block 0 */
                _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
                ret = eraseBlock(0,device,0,TOGGLE_VAL_NEXT,bigDevice,0);
                FLASH_PROG_ERASE_FAIL_RETURN(ret);
            }

            /* flip bits and write word to pi buffer */
            IO_WRITE(bufAddr+j,BIT_FLIP(H2BE4(*p32_1),bitToFlip));
            IO_WRITE(bufAddr+j+PI_FLASH_PAGE_DATA_SIZE/2,
                     BIT_FLIP(H2BE4(*p32_2),bitToFlip));

            /* program page */
            ret = programFullPage(pageCount<<9,TOGGLE_VAL,
                                  device,0,NULL,NULL,
                                  TOGGLE_VAL_NEXT,bigDevice,0);
            FLASH_PROG_ERASE_FAIL_RETURN(ret);

            /* read-back page */
            ret = readFullPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                               bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                               bigDevice,0);

            /* insure no int generated */
            if(flashCheckNoIntr()!=PASS){
                _TRACE(DERROR, fprintf(LogFp,"spurios int generated\n"));
                return FAIL;
            }

            /* check return from read page and data match */
            if(ret = sberrReturnCheck(ret,buf,bufback,0,
                                      PI_FLASH_PAGE_FULL_SIZE)
               != PASS){
                return ret;
            }

        }
        
        /* write correct value of word just used so no lingering biterr */
        IO_WRITE(bufAddr+j,H2BE4(*p32_1));        
        IO_WRITE(bufAddr+j+PI_FLASH_PAGE_DATA_SIZE/2,H2BE4(*p32_2));        

        _TRACE(DSTATUS, fprintf(LogFp,"\n"));

    }

    /*
     * ECC 1st and 2nd half bytes 
     */

    bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
    bufOobAddr = PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE;

    /* erase block 0 */
    _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
    ret = eraseBlock(0,device,0,0,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);
    
    /* transfer data to pi buffer */
    ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
    ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,bufOobAddr);

    p32_2=(u32 *)(buf+PI_FLASH_PAGE_ECC2_OFFSET);
    p32_1=(u32 *)(buf+(PI_FLASH_PAGE_ECC1_OFFSET&0xfffffffc));
    /* loop on bits in word */
    for(i=0;i<22;i++){ /* ignore spec'd two 1 bits at location 8 and 9 */
        if(!(i%3)) intm=!intm, toggleFlashIntMask(intm);
        _TRACE(DSTATUS, fprintf(LogFp," %d %d\n",
                     i+PI_FLASH_ECC2_BIT_START+PI_FLASH_PAGE_ECC2_OFFSET*8,
                     i+PI_FLASH_ECC1_BIT_START+PI_FLASH_PAGE_ECC1_OFFSET*8));
        
        /* flip bit and write word to pi buffer */
        IO_WRITE(bufOobAddr+PI_FLASH_OOB_ECC2_OFFSET,
                 BIT_FLIP(H2BE4(*p32_2),i+PI_FLASH_ECC2_BIT_START));
        IO_WRITE(bufOobAddr+(PI_FLASH_OOB_ECC1_OFFSET&0xfffffffc),
                 BIT_FLIP(H2BE4(*p32_1),i+PI_FLASH_ECC1_BIT_START));
        
        /* program page */
        ret = programFullPage(i<<9,TOGGLE_VAL,device,0,NULL,NULL,
                              TOGGLE_VAL_NEXT,bigDevice,0);
        FLASH_PROG_ERASE_FAIL_RETURN(ret);
        
        /* read-back page */
        ret = readFullPage(TOGGLE_VAL_NEXT,device,i<<9,1,
                           bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                           bigDevice,0);

        /* insure no int generated */
        if(flashCheckNoIntr()!=PASS){
            _TRACE(DERROR, fprintf(LogFp,"spurios int generated\n"));
            return FAIL;
        }

        /* check return from read page and data match */
        if(ret = sberrEccReturnCheck(ret,buf,bufback,0,PI_FLASH_PAGE_FULL_SIZE)
           != PASS){
            return ret;
        }
        
    }
    _TRACE(DSTATUS, fprintf(LogFp,"\n"));
    
    return PASS;
}



/*
 * Also tests:
 *   1) that PI_ERRR register never sets COR_ECC (and UNC_ECC).
 *   2) that the pi reads still properly generate interrupts when
 *      ecc is on.
 */
int piEccSingleBitErrHalf(int device,int bigDevice)
{
    int i,j,k,bitToFlip,wordToFlip,pageCount,ret;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    u32 *p32,val32,bufAddr,bufOobAddr;
    TOGGLE_INIT;

    /*
     * Initialization
     */

    pageCount=0;

    /* random buffer initial usage */
    if(rand()&1)
        TOGGLE;

    /* int mask bit set for this test */
    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_SET_FLASH);

    /* fill page with randoms and correct ecc */
    pageRandEcc(buf);

    /* erase block 0 */
    _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
    ret = eraseBlock(0,device,0,0,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
    bufOobAddr = PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE;
    
    /* transfer data to pi buffer */
    ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
    ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                  PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE);


    /*
     * Test bit-flip in first half data
     */

    _TRACE(DSTATUS, fprintf(LogFp,"bit flipping in 1st half data\n"));

    /* clear PI_ERROR */
    IO_WRITE(PI_ERROR_REG,0);

    /* choose bit to flip in first half data */
    wordToFlip = rand()&(PI_FLASH_PAGE_DATA_SIZE/8 - 1);
    bitToFlip = rand()&0x1f;
    p32 = (u32 *)(buf+wordToFlip*4);

    /* flip bits and write word to pi buffer */
    IO_WRITE(bufAddr+wordToFlip*4,BIT_FLIP(H2BE4(*p32),bitToFlip));

    /* program page */
    ret = programFullPage(pageCount<<9,TOGGLE_VAL,device,0,NULL,NULL,
                          TOGGLE_VAL_NEXT,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    /* read-back page */
    ret = readFullPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                       bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,1);

    /* check and clear int */
    if(flashCheckClearIntr()!=PASS){
        return FAIL;
    }

    /* check return from read page and data match */
    if(ret = sberrReturnCheck(ret,buf,bufback,0,PI_FLASH_PAGE_FULL_SIZE)
       !=PASS){
        return ret;
    }

    /* insure no ecc bits in PI_ERROR flipped */
    val32 = IO_READ(PI_ERROR_REG);
    if( (val32&PI_ERROR_CORRECTABLE_ECC) ||
        (val32&PI_ERROR_UNCORRECTABLE_ECC) ){
        return FAIL;
    }
    

    /*
     * Fix flipped bit for next test
     */
    IO_WRITE(bufAddr+wordToFlip*4,H2BE4(*p32));


    /*
     * Test bit-flip in first half ecc bits (oob)
     */

    _TRACE(DSTATUS, fprintf(LogFp,"bit flipping in 1st half ecc\n"));


    /* choose bit to flip in first half ecc */
    wordToFlip = PI_FLASH_OOB_ECC1_OFFSET/4;
    bitToFlip = RAND_BIT_0_21 + PI_FLASH_ECC1_BIT_START;
    p32 = (u32 *)(buf+PI_FLASH_PAGE_DATA_SIZE+wordToFlip*4);

    /* flip bits and write word to pi buffer */
    IO_WRITE(bufOobAddr+wordToFlip*4,BIT_FLIP(H2BE4(*p32),bitToFlip));

    /* program page */
    ret = programFullPage(pageCount<<9,TOGGLE_VAL,device,0,NULL,NULL,
                          TOGGLE_VAL_NEXT,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    /* read-back page */
    ret = readFullPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                       bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,1);

    /* check and clear int */
    if(flashCheckClearIntr()!=PASS){
        return FAIL;
    }

    /* check return from read page and data match */
    if(ret = sberrEccReturnCheck(ret,buf,bufback,0,PI_FLASH_PAGE_FULL_SIZE)
       !=PASS){
        return ret;
    }
    
    /* insure no ecc bits in PI_ERROR flipped */
    val32 = IO_READ(PI_ERROR_REG);
    if( (val32&PI_ERROR_CORRECTABLE_ECC) ||
        (val32&PI_ERROR_UNCORRECTABLE_ECC) ){
        _TRACE(DERROR,fprintf(LogFp,"XXXXXXXXXXXXXXXXXXXXX\n"));
        //return FAIL; // XXX put this back
    }
    IO_WRITE(PI_ERROR_REG,0);

    /*
     * Fix flipped bit for next test
     */
    IO_WRITE(bufOobAddr+wordToFlip*4,H2BE4(*p32));


    /*
     * Test bit-flip in second half data, reading both entire
     * page and 2nd half page.
     */

    _TRACE(DSTATUS, fprintf(LogFp,"bit flipping in 2nd half data\n"));

    /* choose bit to flip in first half data */
    wordToFlip = rand()&(PI_FLASH_PAGE_DATA_SIZE/8 - 1);
    wordToFlip += PI_FLASH_PAGE_DATA_SIZE/8;
    bitToFlip = rand()&0x1f;
    p32 = (u32 *)(buf+wordToFlip*4);

    /* flip bits and write word to pi buffer */
    IO_WRITE(bufAddr+wordToFlip*4,BIT_FLIP(H2BE4(*p32),bitToFlip));

    /* program page */
    ret = programFullPage(pageCount<<9,TOGGLE_VAL,device,0,NULL,NULL,
                          TOGGLE_VAL_NEXT,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    /* read-back page */
    ret = readFullPage(TOGGLE_VAL_NEXT,device,pageCount<<9,1,
                       bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,0);

    /* check return from read page and data match */
    if(ret = sberrReturnCheck(ret,buf,bufback,0,PI_FLASH_PAGE_FULL_SIZE)
       !=PASS){
        return ret;
    }

    /* read-back with only 2nd half page */
    ret = readSecondHalfPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                             bufback+PI_FLASH_PAGE_DATA_SIZE/2,
                             bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,1);

    /* check and clear int */
    if(flashCheckClearIntr()!=PASS){
        return FAIL;
    }

    /* check return from read page and data match */
    if(ret = sberrReturnCheck(ret,buf,bufback,PI_FLASH_PAGE_DATA_SIZE/2,
                              PI_FLASH_PAGE_DATA_SIZE/2+PI_FLASH_OOB_SIZE)
       !=PASS){
        return ret;
    }
    

    /*
     * Fix flipped bit for next test
     */
    IO_WRITE(bufAddr+wordToFlip*4,H2BE4(*p32));


    /*
     * Test bit-flip in second half ecc bits (oob)
     */

    _TRACE(DSTATUS, fprintf(LogFp,"bit flipping in 2nd half ecc\n"));

    /* choose bit to flip in first half ecc */
    wordToFlip = PI_FLASH_OOB_ECC2_OFFSET/4;
    bitToFlip = RAND_BIT_0_21 + PI_FLASH_ECC2_BIT_START;
    p32 = (u32 *)(buf+PI_FLASH_PAGE_DATA_SIZE+wordToFlip*4);

    /* flip bits and write word to pi buffer */
    IO_WRITE(bufOobAddr+wordToFlip*4,BIT_FLIP(H2BE4(*p32),bitToFlip));

    /* program page */
    ret = programFullPage(pageCount<<9,TOGGLE_VAL,device,0,NULL,NULL,
                          TOGGLE_VAL_NEXT,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    /* read-back page */
    ret = readFullPage(TOGGLE_VAL_NEXT,device,pageCount<<9,1,
                       bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,0);

    /* check return from read page and data match */
    if(ret = sberrEccReturnCheck(ret,buf,bufback,0,PI_FLASH_PAGE_FULL_SIZE)
       !=PASS){
        return ret;
    }

    /* read-back with only 2nd half page */
    ret = readSecondHalfPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                             bufback+PI_FLASH_PAGE_DATA_SIZE/2,
                             bufback+PI_FLASH_PAGE_DATA_SIZE,bigDevice,0);

    /* check return from read page and data match */
    if(ret = sberrEccReturnCheck(ret,buf,bufback,PI_FLASH_PAGE_DATA_SIZE/2,
                              PI_FLASH_PAGE_DATA_SIZE/2+PI_FLASH_OOB_SIZE)
       !=PASS){
        return ret;
    }
    
    return PASS;
}


/* can't have multiple locations equal */
void setFlipLocations(u8 *bitErrorLoc,int *bitFlipLocations)
{
    int i,candidate,current=0;

    /* data1 */
    for(i=0;i<bitErrorLoc[0];i++){
        candidate = rand()&(PI_FLASH_PAGE_DATA_SIZE*4-1);
        while(i>0 && (candidate == bitFlipLocations[current-1])){
            candidate = rand()&(PI_FLASH_PAGE_DATA_SIZE*4-1);
        }
        bitFlipLocations[current++] = candidate;
    }
    /* data2 */
    for(i=0;i<bitErrorLoc[1];i++){
        candidate = (rand()&(PI_FLASH_PAGE_DATA_SIZE*4-1)) +
            PI_FLASH_PAGE_DATA_SIZE*4;
        while(i>0 && (candidate == bitFlipLocations[current-1])){
            candidate = (rand()&(PI_FLASH_PAGE_DATA_SIZE*4-1)) +
                PI_FLASH_PAGE_DATA_SIZE*4;
        }
        bitFlipLocations[current++] = candidate;
    }
    /* ecc1 */
    for(i=0;i<bitErrorLoc[2];i++){
        candidate = (PI_FLASH_PAGE_ECC1_OFFSET&(~3))*8 +
            PI_FLASH_ECC1_BIT_START+RAND_BIT_0_21;
        while(i>0 && (candidate == bitFlipLocations[current-1])){
            candidate = (PI_FLASH_PAGE_ECC1_OFFSET&(~3))*8 +
                PI_FLASH_ECC1_BIT_START+RAND_BIT_0_21;
        }
        bitFlipLocations[current++] = candidate;
    }
    /* ecc2 */
    for(i=0;i<bitErrorLoc[3];i++){
        candidate = (PI_FLASH_PAGE_ECC2_OFFSET&(~3))*8 +
            PI_FLASH_ECC2_BIT_START+RAND_BIT_0_21;
        while(i>0 && (candidate == bitFlipLocations[current-1])){
            candidate = (PI_FLASH_PAGE_ECC2_OFFSET&(~3))*8 +
                PI_FLASH_ECC2_BIT_START+RAND_BIT_0_21;
        }
        bitFlipLocations[current++] = candidate;
    }

    if(current<4)
        bitFlipLocations[current] = -1;
}

void flipPiBufBits(int piBuf,int *bitFlipLocations,u8 *buf)
{
    int wordToFlip,wordToFlipPrev,bitToFlip,bitToFlip2,i;
    u32 bufAddr,*p32;

    /* extra logic to take care of case when 2 consecutive bits for flipping
     * are in same word (they must always be consecutive due to double
     * bit error position constraints).
     */
    wordToFlipPrev=-1;
    for(i=0; (i<4) && (bitFlipLocations[i]>=0); i++){
        wordToFlip = bitFlipLocations[i]>>(2+3); /* to bytes, to words */
        if(wordToFlip == wordToFlipPrev){
            bitToFlip2 = bitToFlip;
        }
        bitToFlip = bitFlipLocations[i] - (wordToFlip<<(2+3));
        p32 = (u32 *)(buf+wordToFlip*4);
        if((wordToFlip*4)<PI_FLASH_PAGE_DATA_SIZE){
            /* data section */
            bufAddr = PI_BUFFER_0_START+piBuf*PI_FLASH_PAGE_DATA_SIZE +
                wordToFlip*4; 
        }
        else{
            /* oob ecc section */
            bufAddr = PI_BUFFER_0_OOB_START+piBuf*PI_FLASH_OOB_SIZE +
                wordToFlip*4 - PI_FLASH_PAGE_DATA_SIZE;
        }

        if(wordToFlip == wordToFlipPrev){
            IO_WRITE(bufAddr,BIT_FLIP2(H2BE4(*p32),bitToFlip,bitToFlip2));
        }
        else{
            IO_WRITE(bufAddr,BIT_FLIP(H2BE4(*p32),bitToFlip));
        }
        wordToFlipPrev = wordToFlip;
    }
}

void unflipPiBufBits(int piBuf,int *bitFlipLocations,u8 *buf)
{
    int wordToFlip,wordToFlipPrev,bitToFlip,bitToFlip2,i;
    u32 bufAddr,*p32;

    /* extra logic to take care of case when 2 consecutive bits for flipping
     * are in same word (they must always be consecutive due to double
     * bit error position constraints).
     */
    wordToFlipPrev=-1;
    for(i=0; (i<4) && (bitFlipLocations[i]>=0); i++){
        wordToFlip = bitFlipLocations[i]>>(2+3); /* to bytes, to words */
        if(wordToFlip == wordToFlipPrev){
            bitToFlip2 = bitToFlip;
        }
        bitToFlip = bitFlipLocations[i] - (wordToFlip<<(2+3));
        p32 = (u32 *)(buf+wordToFlip*4);
        if((wordToFlip*4)<PI_FLASH_PAGE_DATA_SIZE){
            /* data section */
            bufAddr = PI_BUFFER_0_START+piBuf*PI_FLASH_PAGE_DATA_SIZE +
                wordToFlip*4; 
        }
        else{
            /* oob ecc section */
            bufAddr = PI_BUFFER_0_OOB_START+piBuf*PI_FLASH_OOB_SIZE +
                wordToFlip*4 - PI_FLASH_PAGE_DATA_SIZE;
        }

        IO_WRITE(bufAddr,H2BE4(*p32));

        wordToFlipPrev = wordToFlip;
    }
}

int dberrReturnCheck(int ret)
{
    if(ret==DRIVER_ERROR){
        return TESTERROR;
    }
    else if(ret!=DRIVER_ECC_DBL_BITERR && ret!=DRIVER_ECC_SGL_DBL_BITERR){
        _TRACE(DERROR, fprintf(LogFp,
                  "  page read result not DRIVER_ECC_DBL_BITERR\n"
                  "  or DRIVER_ECC_SGL_DBL_BITERR. Was %d\n",ret));
        return FAIL;
    }

    return PASS;
}

/*
 * bitErrorLoc: 4 byte array with,
 *    bitErrorLoc[0] = num random bit errors in data1
 *    bitErrorLoc[1] = num random bit errors in data2
 *    bitErrorLoc[2] = num random bit errors in ecc1
 *    bitErrorLoc[3] = num random bit errors in ecc2
 *
 * secondHalfOnlyRead: only readback second half of
 *    flash page. Careful, because if errors spec'd in
 *    first half (data or ecc) only, will fail.
 */
int piEccDoubleBitErr(int device,int bigDevice,int numCycles,
                      u8 *bitErrorLoc,int enableInt,int secondHalfOnlyRead)
{
    int i,j,k,pageCount,ret;
    u8 buf[PI_FLASH_PAGE_FULL_SIZE],bufback[PI_FLASH_PAGE_FULL_SIZE];
    u32 *p32_1,*p32_2,val32,bufAddr,bufOobAddr;
    int bitFlipLocations[4]; /* just the locations in contig 528B page
                              * list ends with negative number if less
                              * than 4 entries
                              */
    TOGGLE_INIT;
    int intm = 0;  /* start with int mask bit clr */
    IO_WRITE(MI_INTR_EMASK_REG, MI_INTR_MASK_CLR_FLASH);

    /* random buffer initial usage */
    if(rand()&1)
        TOGGLE;

    /* fill page with randoms and correct ecc */
    pageRandEcc(buf);

    /* clear error register */
    IO_WRITE(PI_ERROR_REG,0);

    /* erase block 0 */
    _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
    ret = eraseBlock(0,device,0,0,bigDevice,0);
    FLASH_PROG_ERASE_FAIL_RETURN(ret);

    bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
    
    /* transfer data to pi buffer */
    ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
    ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                  PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE);

    _TRACE(DSTATUS, fprintf(LogFp," double bit errors:\n"));
    pageCount = 0;
    for( j=0; j<numCycles; j++){
        if(!(j%3)) intm=!intm, toggleFlashIntMask(intm);

        if(pageCount == PI_FLASH_PAGES_PER_BLOCK){
            pageCount = 0;
            
            /* convenient time to toggle for buffer coverage test */
            TOGGLE;
            bufAddr = PI_BUFFER_0_START+TOGGLE_VAL*PI_FLASH_PAGE_DATA_SIZE;
            
            /* transfer data to pi buffer */
            ioWriteBuffer(buf,PI_FLASH_PAGE_DATA_SIZE,bufAddr);
            ioWriteBuffer(buf+PI_FLASH_PAGE_DATA_SIZE,PI_FLASH_OOB_SIZE,
                          PI_BUFFER_0_OOB_START+TOGGLE_VAL*PI_FLASH_OOB_SIZE);
            
            /* erase block 0 */
            _TRACE(DSTATUS, fprintf(LogFp,"   erasing block\n"));
            ret = eraseBlock(0,device,0,TOGGLE_VAL_NEXT,bigDevice,0);
            FLASH_PROG_ERASE_FAIL_RETURN(ret);
        }
        
        /* flip bits and write word to pi buffer */
        setFlipLocations(bitErrorLoc,bitFlipLocations);
        _TRACE(DSTATUS,fprintf(LogFp,"  bit error locations:\n     "));
        for(i=0;i<4;i++){
            if(bitFlipLocations[i] < 0)
                break;
            _TRACE(DSTATUS,fprintf(LogFp," %d",bitFlipLocations[i]));
        }
        _TRACE(DSTATUS,fprintf(LogFp, "\n"));
        flipPiBufBits(TOGGLE_VAL,bitFlipLocations,buf);
        
        /* program page */
        ret = programFullPage(pageCount<<9,TOGGLE_VAL,
                              device,0,NULL,NULL,
                              TOGGLE_VAL_NEXT,bigDevice,0);
        FLASH_PROG_ERASE_FAIL_RETURN(ret);
        
        /* read-page */
        if(secondHalfOnlyRead){
            ret = readSecondHalfPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                           bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                           bigDevice,enableInt);
        }
        else{
            ret = readFullPage(TOGGLE_VAL_NEXT,device,(pageCount++)<<9,1,
                           bufback,bufback+PI_FLASH_PAGE_DATA_SIZE,
                           bigDevice,enableInt);
        }

        /* if int supposed to be generated, insure it happened */
        if(enableInt && (flashCheckClearIntr()!=PASS)){
            _TRACE(DLOG, fprintf(LogFp,"int not generated correctly.\n"));
            return FAIL;
        }
        
        /* insure no spurious int generated */
        if(!enableInt && (flashCheckNoIntr()!=PASS)){
            _TRACE(DERROR, fprintf(LogFp,"spurios int generated.\n"));
            return FAIL;
        }

        /* insure no ecc bits in PI_ERROR flipped */
        val32 = IO_READ(PI_ERROR_REG);
        if( (val32&PI_ERROR_CORRECTABLE_ECC) ||
            (val32&PI_ERROR_UNCORRECTABLE_ECC) ){
            _TRACE(DLOG, fprintf(LogFp,
                         "PI_ERROR ECC bits fired when should not.\n"));
            return FAIL;
        }
        
        /* check return from read page and data match */
        if(ret = dberrReturnCheck(ret) != PASS){
            return ret;
        }
        
        /* write correct value of words just used so no lingering biterr */
        unflipPiBufBits(TOGGLE_VAL,bitFlipLocations,buf);
    
    }
            
    _TRACE(DSTATUS, fprintf(LogFp,"\n"));
 
    return PASS;
}


/* 
 * ECC, 1 (ECC generation)
 */
void eccGen(const u32 flashSimDeviceSize[])
{
    int ret;

    _TRACE(DLOG, fprintf(LogFp,"Running eccGeneration Test.\n"));
    fflush(NULL);
    ret = piEccGen(10,0,IS_BIG_DEVICE(flashSimDeviceSize[0]));
    printf("eccGeneration ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);
}


/*
 * ECC, 2 (Read valid)
 */
void eccReadValid(const u32 flashSimDeviceSize[])
{
    int ret;

    _TRACE(DLOG, fprintf(LogFp,"Running eccReadValid Test.\n"));
    fflush(NULL);
    ret = piEccReadNoErr(10,0,IS_BIG_DEVICE(flashSimDeviceSize[0]));
    printf("eccReadValid ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);
}


/*
 * ECC, 3 (Single bit error)
 */
void eccSingleBitErr(const u32 flashSimDeviceSize[])
{
    int ret;

    _TRACE(DLOG, fprintf(LogFp,"Running eccSingleBitErrorWalk Test.\n"));
    fflush(NULL);
    ret = piEccSingleBitErrWalk(0,IS_BIG_DEVICE(flashSimDeviceSize[0]));
    printf("eccSingleBitErrorWalk ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);

    _TRACE(DLOG, fprintf(LogFp,"Running eccSingleBitErrorHalf Test.\n"));
    fflush(NULL);
    ret = piEccSingleBitErrHalf(0,IS_BIG_DEVICE(flashSimDeviceSize[0]));
    printf("eccSingleBitErrorHalf ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);

}


/*
 * ECC, 4 (Double bit error)
 */
void eccDoubleBitErr(const u32 flashSimDeviceSize[])
{
    int ret;
    u8 bitErrorLoc[4];

    _TRACE(DLOG, fprintf(LogFp,"Running eccDoubleBitError Test.\n"));
    fflush(NULL);

    /* first page data randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---first page data randoms, no int\n"));
    bitErrorLoc[0]=2;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* first page data randoms, int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---first page data randoms, int\n"));
    bitErrorLoc[0]=2;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,1,0);
    if(ret != PASS)
        goto printresult;

    /* first page ecc randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---first page ecc randoms, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=2;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),2,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* first page ecc randoms, int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---first page ecc randoms, int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=2;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),2,
                            bitErrorLoc,1,0);
    if(ret != PASS)
        goto printresult;

    /* first page mix randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---first page ecc randoms, int\n"));
    bitErrorLoc[0]=1;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=1;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* second page data randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---second page data randoms, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=2;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* second page data randoms, int gen, 2nd half read */
    _TRACE(DSTATUS, fprintf(LogFp,
                    "---second page data randoms, int, 2nd half read\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=2;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,1,1);
    if(ret != PASS)
        goto printresult;

    /* second page ecc randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---second page ecc randoms, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=2;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),2,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* second page ecc randoms, int gen, 2nd half read */
    _TRACE(DSTATUS, fprintf(LogFp,
                    "---second page ecc randoms, int, 2nd half read\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=2;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),2,
                            bitErrorLoc,1,1);
    if(ret != PASS)
        goto printresult;

    /* second page mix randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---second page ecc randoms, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=1;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=1;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),5,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* both page data randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---both page data randoms, no int\n"));
    bitErrorLoc[0]=2;
    bitErrorLoc[1]=2;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* both page data randoms, int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---both page data randoms, int\n"));
    bitErrorLoc[0]=2;
    bitErrorLoc[1]=2;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,1,0);
    if(ret != PASS)
        goto printresult;

    /* both page ecc randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---both page ecc randoms, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=2;
    bitErrorLoc[3]=2;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* both page mixed randoms, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---both page mixed randoms, no int\n"));
    bitErrorLoc[0]=1;
    bitErrorLoc[1]=1;
    bitErrorLoc[2]=1;
    bitErrorLoc[3]=1;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

    /* mixed single/double, no int gen */
    _TRACE(DSTATUS, fprintf(LogFp,"---mixed single/double, no int\n"));
    bitErrorLoc[0]=0;
    bitErrorLoc[1]=1;
    bitErrorLoc[2]=1;
    bitErrorLoc[3]=1;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;
    bitErrorLoc[0]=1;
    bitErrorLoc[1]=0;
    bitErrorLoc[2]=1;
    bitErrorLoc[3]=1;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;
    bitErrorLoc[0]=1;
    bitErrorLoc[1]=1;
    bitErrorLoc[2]=0;
    bitErrorLoc[3]=1;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;
    bitErrorLoc[0]=1;
    bitErrorLoc[1]=1;
    bitErrorLoc[2]=1;
    bitErrorLoc[3]=0;
    ret = piEccDoubleBitErr(0,IS_BIG_DEVICE(flashSimDeviceSize[0]),1,
                            bitErrorLoc,0,0);
    if(ret != PASS)
        goto printresult;

 printresult:
    printf("eccDoubleBitError ");
    OUTPUT_TEST_PASSFAIL(ret);
    fflush(NULL);
}