davincihd_nandflash_read.c

用于dm6467 开发平台的uboot源码

/*
 *  Copyright 2007 by Spectrum Digital Incorporated.
 *  All rights reserved. Property of Spectrum Digital Incorporated.
 */

/*
 *  NAND Flash interface
 *
 */

#include "davincihd_nandflash.h"

/*
 *  NAND Organization
 */
extern NAND_ORGANIZATION nand_org;

/*
 *  NAND Flash timeout
 */
extern Int32 nand_rw_timeout;

/* ------------------------------------------------------------------------ *
 *                                                                          *
 *  _NAND_read8( rx, use_ecc )                                              *
 *      Read a page from NAND                                               *
 *                                                                          *
 *      Inputs:                                                             *
 *          rx         = address of rx buffer [ any address ]               *
 *          use_ecc    = use ECC?                                           *
 *                                                                          *
 *      Return:                                                             *
 *          =0  pass                                                        *
 *          >0  failed - bad pages                                          *
 *          -1  timeout                                                     *
 *                                                                          *
 * ------------------------------------------------------------------------ */
Uint32 _NAND_read8( Uint32 rx, Uint32 use_ecc )
{
    Int16 i, j;
    volatile Uint8* rx8 = ( volatile Uint8* )rx;

    /* Spare + ECC */
    Uint32 computed_ecc;
    Uint8  spare_ecc[4];
    Uint32 spare_ecc32;
    Int16 retcode = 0;

    /* Start ECC */
    if ( use_ecc )
        _NAND_startECC( );

    /* Read MAIN array */
    i = nand_org.page_size;
    while ( i-- )
        *rx8++ = NAND_DATA;

    /* Compute ECC */
    if ( use_ecc )
    {
        computed_ecc = _NAND_readECC( );
        computed_ecc &= 0x0FFF0FFF;
    }

    /* Read & Store Spare array */
    i = nand_org.spare_size;
    if ( use_ecc )
    {
        for ( j = 0 ; j < 4 ; j++ )
        {
            spare_ecc[j] = NAND_DATA;       // Read SPARE ECC
            *rx8++ = spare_ecc[j];
        }

        spare_ecc32 = *( Uint32* )( &spare_ecc[0] );
        spare_ecc32 &= 0x0FFF0FFF;

        if ( spare_ecc32 != computed_ecc )  // Compare ECCs
        {
            retcode++;
            nand_org.invalid_page_table[nand_org.invalid_pages++] = i;
        }
        i -= 4;
    }

    while ( i-- )
        *rx8++ = NAND_DATA;

    return retcode;
}

/* ------------------------------------------------------------------------ *
 *                                                                          *
 *  _NAND_readPage( start_page, rx, page_count )                            *
 *      Read pages from NAND                                                *
 *                                                                          *
 *      Inputs:                                                             *
 *          start_page = start page                                         *
 *          rx         = address of rx buffer [ any address ]               *
 *          page_count = # of pages                                         *
 *                                                                          *
 *      Return:                                                             *
 *          =0  pass                                                        *
 *          >0  failed - bad pages                                          *
 *          -1  timeout                                                     *
 *                                                                          *
 * ------------------------------------------------------------------------ */
Int16 _NAND_readPage( Uint32 start_page, Uint32 rx, Uint32 page_count )
{
    Uint32 i;
    Uint32 page_addr;
    Uint32 retcode = 0;

    for ( i = start_page ; i < start_page + page_count ; i++ )
    {
        /* Fix for large page addressing */
        page_addr = i * nand_org.page_addr_incr;

        /* Read a single page */
        _NAND_CMD( CMD_READ );              // Read page
        _NAND_PAGE_ADDR( page_addr );       // Page address

        /* Use Read confirm? */
        if ( nand_org.use_read_confirm )
            _NAND_CMD( CMD_READ_CONFIRM );  // Read Confirm

        if ( _NAND_busywait( nand_rw_timeout ) )
            return NAND_ERR_TIMEOUT;

        /* Read page in 8 bit mode */
        if ( nand_org.bus_width == 8 )
            retcode += _NAND_read8( rx, 0 );
    }

    return retcode;
}