tools/build-R2_19_3/fsboot/cbl/nand/rflnandflash.c

Go to the documentation of this file.

/* vi: set sw=2 ts=2: */
//==========================================================================
//
//      rflnandflash.c
//
//      NAND Flash support used in Axis RFL
//
//==========================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// -------------------------------------------                              
// The contents of this file are subject to the Red Hat eCos Public License 
// Version 1.1 (the "License"); you may not use this file except in         
// compliance with the License.  You may obtain a copy of the License at    
// http://www.redhat.com/                                                   
//                                                                          
// Software distributed under the License is distributed on an "AS IS"      
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the 
// License for the specific language governing rights and limitations under 
// the License.                                                             
//                                                                          
// The Original Code is eCos - Embedded Configurable Operating System,      
// released September 30, 1998.                                             
//                                                                          
// The Initial Developer of the Original Code is Red Hat.                   
// Portions created by Red Hat are                                          
// Copyright (C) 1998, 1999, 2000, 2001 Red Hat, Inc.                             
// All Rights Reserved.                                                     
// -------------------------------------------                              
//                                                                          
//####COPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    starvik@axis.com
// Contributors: starvik@axis.com
// Date:         2006-03-11
// Purpose:      
// Description:  
//              
// This code is part of RedBoot (tm).
//
//
//####DESCRIPTIONEND####
//
//==========================================================================

#define diag_printf printf

/* Debug messages. */
#define D(x) x
/* Detailed debug messages, verbose. */
#define D_D(x) x 

//#include <redboot.h>
#include <linuxerr.h>
#include <nandflash.h>

#include <axisrfl/types.h>
#include <axisrfl/mtd.h>
#include <axisrfl/mtd_nand.h>
#include <axisrfl/rflflash.h>
//#include <cyg/hal/hardware.h>
//#include <cyg/hal/nandflash.h>

#include <axisrfl/funcs.h>

#include <string.h>


/* Buffer sizes, for mtd */
//#define DATA_BUF_SIZE (1024 * (128 + 2)) /* (512 + 16) ok for small chips */
//#define OOB_BUF_SIZE (32768)             /* (512) ok for small chips      */
// Elphel !!!!
//#define DATA_BUF_SIZE (2048)
//#define OOB_BUF_SIZE (1024) 
//#define DATA_BUF_SIZE (4096 * 2)
//#define DATA_BUF_SIZE (4096)
#define DATA_BUF_SIZE (2048 + 128)

//#define DATA_BUF_SIZE (2048)
#define OOB_BUF_SIZE (4096) 

/* Buffers for mtd */
u_char data_buf[DATA_BUF_SIZE];
u_char oob_buf[OOB_BUF_SIZE];

/* Mtd structures */
static struct mtd_info mtd_info;
static struct nand_chip nand_chip;

/* main mtd structure referring to our NAND flash */
static struct mtd_info *our_mtd = NULL;

/* Stuff for rflflash_nand_rw */
#define ROUND_DOWN(value, boundary)      ((value) & (~((boundary)-1)))
#define NAND_ECC_SIZE  (512)

#define NAND_READ  (0)
#define NAND_WRITE (1)
#define NAND_CSUM  (2)

/* Value to use for end when don't have anything better */
#define NO_END_LIMIT    (0xffffffff)

/* Minimum size to checksum over, necessary to get ECC operating correctly. */
#define CSUM_CHUNK_SIZE (NAND_ECC_SIZE)

/* testing */
/* WARNING: enabling any of these will force (artificial) bad blocks into the
 * flash. These _cannot_ be erased unless the mtd layer is patched!  */
/* Note: When testing, the addresess below must be chosen to correspond
 * to the image being downloaded. */
#define TEST_WRITE_FAILED (0)
#define TEST_WRITE_BADADDR (0x48000)
#define TEST_ERASE_FAILED (0)
#define TEST_ERASE_FILL (0) /* fill to end of flash when set, else one block */
#define TEST_ERASE_BADADDR (0x268000)

/* Contains integer larger than zero on error defined in rflflash.h.  */
unsigned long errno_flash;

static unsigned verbose_nand = 0;
/*
 * Read/write nand flash, with badblock skip 
 * From U-Boot 1.4.4, modified
 * Modified to skip bad blocks developing during write
 * Operates on an mtd, mode may be read, write or checksum.
 * Partition operated on is start .. end-1, with len bytes of (valid) data
 * retlen will be set to # bytes operated on (if != NULL)
 * retcsum will be set to checksum if != NULL and mode is checksum
 * buffer is read/write buffer, may be NULL when checksumming.
 */
static int
rflflash_nand_rw (struct mtd_info* mtd, int mode,
                         size_t start, size_t end, size_t len,
                         size_t *retlen, unsigned long *retcsum, 
                                                                         u_char *buffer)
{
        int ret = 0, n, total = 0;
        static u_char csumbuf[CSUM_CHUNK_SIZE];
        unsigned long int csum = 0;
        int i;
        size_t this_len;
        u_char *buf = buffer;

        /* eblk (once set) is the start of the erase block containing the
         * data being processed.
         */
        size_t eblk = ~0;       /* force mismatch on first pass */
        size_t erasesize = mtd->erasesize;

        while (len && start < end) 
        {
                if ((start & (-erasesize)) != eblk) 
                {
                        /* have crossed into new erase block, deal with
                         * it if it is marked bad.
                         */
                        eblk = start & (-erasesize); /* start of block */
                        if (mtd->block_isbad (mtd, eblk)) {
                          //D_D(diag_printf("nand_rw: bad block, skipping\n"));
                          if (mode == NAND_WRITE) {
                            if (verbose_nand) {
                              printf("Skipping bad block 0x%x, 0x%8.8x-0x%8.8x\n", 
                                     eblk/erasesize, 
                                     eblk, 
                                     eblk+(1*erasesize)-1);
                            }
                          }

                          start += erasesize;
                          continue;
                        }
                        if (mode == NAND_WRITE) {
                          unsigned block = start/mtd->erasesize;
                          if (verbose_nand) {
                            printf("Writing block 0x%x, 0x%8.8x-0x%8.8x\n", 
                                   block, block*mtd->erasesize, (block+1)*mtd->erasesize);
                          }
                        }

                }
                /* The ECC will not be calculated correctly if
                   less than 512 is written or read */
                /* Is request at least 512 bytes AND it starts on a proper boundary */
                if((start != ROUND_DOWN(start, NAND_ECC_SIZE)) || (len < NAND_ECC_SIZE))
                {
                        D(diag_printf("Warning nand accesses should be at least 512 bytes and start on a 512 byte boundary\n"));

                }

                /* how much to read/write until the end of this eraseblock */
                this_len = min_t(size_t, 
                                 (mode == NAND_CSUM) ? CSUM_CHUNK_SIZE : len, 
                                             eblk + erasesize - start);

                if (mode == NAND_WRITE)
                {
                  //              printf("HERE\n");
                        ret = mtd->write_ecc(mtd, start, this_len,
                                             (size_t *)&n, (u_char*)buf, NULL, NULL);
#if TEST_WRITE_FAILED
                        /* Test code - force bad block */
                        if (start == TEST_WRITE_BADADDR) 
                        {
        D(diag_printf("nand_write: forcing bad block at 0x%x\n", start));
                                ret = -EIO;
                        }
#endif
                        if (ret == -EIO) /* write failed: mark block as bad, skip and continue */
                        {
                          printf("Block 0x%x failed during write, 0x%8.8x-0x%8.8x\n", 
                                 start/erasesize, 
                                 start, 
                                 start+erasesize);
                          
                    mtd->block_markbad(mtd, start); 

                                /* Now we need to restart writing the data so far written to this
                                 * block to the next one. Thus, we must back up the input buf pointer
                                 * as far as we have gotten into this block.
                                 * This assumes that we started writing buf at the start of a block.
                                 * A reasonable assumption given that partitions are block aligned. */
                                buf -= start - eblk; /* how far into the block we are */
                                total -= start - eblk;
                                len += start - eblk;
                                start = eblk + erasesize; /* start of next block */

                                /* And in case the assumption is false: */
                                if (buf < buffer)
                                {
                                        start += buffer - buf;
                                        total += buffer - buf;
                                        len -= buffer - buf;
                                        buf = buffer;
                                }

                                continue;
                        }
                }
          else if (mode == NAND_READ)
                        ret = mtd->read_ecc(mtd, start, this_len,
                                            (size_t *)&n, (u_char*)buf, NULL, NULL);
                else if (mode == NAND_CSUM)
                        ret = mtd->read_ecc(mtd, start, this_len,
                                            (size_t *)&n, csumbuf, NULL, NULL);
                else
                        n = len; /* bad mode, just get out of here */

                if (ret)
                        break;

                if (mode == NAND_CSUM)
                        for (i = 0; i < n; i++)
                                csum += csumbuf[i];

                start  += n;
                buf   += n;
                total += n;
                len   -= n;
        }
        
        if (len && (start >= end)) {
          printf("Error. Writing exceeded the max_dst address 0x%8.8x\n", end);
          exit(0);
        }
        if (retlen)
                *retlen = total;
        if (retcsum)
                *retcsum = csum;

        return ret;
}


/* with initial rflflash_init */

int 
rflflash_nand_do_erase(unsigned long start, unsigned long end)
{
  rflflash_init();

  if (start >= our_mtd->size) {
    printf("Cannot erase from 0x%8.8x, nand size is 0x%8.8x\n", end, our_mtd->size);
    exit(0);
  }
  if (end >= our_mtd->size) {
    printf("Cannot erase to 0x%8.8x, nand size is 0x%8.8x\n", end, our_mtd->size);
    exit(0);
  }
  return (rflflash_nand_erase(our_mtd, start, end));
}

/* 
 * erase flash between addresses indicated, skipping bad blocks
 */
int
rflflash_nand_erase (struct mtd_info *mtd, 
                                 unsigned long start, unsigned long end)
{
  struct erase_info mtd_erase;
        int mtd_err;

        D(diag_printf(">rflflash_nand_erase(%s) Erase from 0x%lx to 0x%lx\n", 
                      __FILE__, start, end));

        memset(&mtd_erase, 0, sizeof(mtd_erase));

        while (start < end) 
        {
                if (!mtd->block_isbad(mtd, start))
                {
                        mtd_erase.addr = start;
                        mtd_erase.len = mtd->erasesize;
                        mtd_erase.mtd = mtd;
                        mtd_err = mtd->erase(mtd, &mtd_erase);
                        //                      D_D(diag_printf("Erasing block at 0x%lx, status %d\n", start, mtd_err));
                        if (verbose_nand) {
                          unsigned block = start/mtd->erasesize;
                          printf("Erasing block 0x%x, 0x%8.8x-0x%8.8x\n", 
                                 block, block*mtd->erasesize, (block+1)*mtd->erasesize);
                        }

#if TEST_ERASE_FAILED
                        /* Test code - force bad block */
#if TEST_ERASE_FILL
                        if (start >= TEST_ERASE_BADADDR)
#else
                        if (start == TEST_ERASE_BADADDR) 
#endif
                        {
        D(diag_printf("nand_erase: forcing bad block at 0x%x\n", start));
                                mtd_err = -EIO;
                        }
#endif
                        if (mtd_err)
                        {
                                if (mtd_err == -EIO) /* write failed, so we mark block as bad */
                                {
                                        mtd->block_markbad(mtd, start); 
                                        D_D(diag_printf("Block at 0x%lx has become bad, skipping\n", start));
                                }
                                else
                                        return mtd_err;
                        }
                } else {
                  unsigned block = start/mtd->erasesize;
                  
//                if (verbose_nand) {
                    printf("Skipping bad block 0x%x, 0x%8.8x-0x%8.8x\n", 
                           block, 
                           block*mtd->erasesize, 
                           (block+1)*mtd->erasesize-1);
//                }

                  //D_D(diag_printf("Block at 0x%lx is bad, skipping.\n", start));
                }
                start += mtd->erasesize;
        }
        return 0;
}


/* 
 * Write size octets from buffer source to memory starting at offset.
 * Prior to write, erase whole area from offset to end_offset-1.
 * Limitation: Must be complete eraseblocks, and start at start of a block.
 */
unsigned long
rflflash_write (unsigned char *source, unsigned long offset,
                unsigned long end_offset, unsigned long size)
{
        int mtd_err;
        size_t written_size;

        /*      printf(">rflflash_write(%s) %x, %x, %x, %x\n", 
                __FILE__, source, offset, end_offset, size); */

        if (our_mtd)
        {
                mtd_err = rflflash_nand_erase(our_mtd, offset, end_offset);
                if (mtd_err)
                        errno_flash |= ERROR_ERASE_FAILED;
                else
                {
                  mtd_err = rflflash_nand_rw (our_mtd, NAND_WRITE, 
                                                                offset, end_offset, size, 
                                                                                                                                        &written_size, NULL, source);
                        if (mtd_err || written_size != size)
                                errno_flash |= ERROR_WRITE_FAILED;
                }
        }
        else
                errno_flash = ERROR_NO_CHIP_FOUND;

  return errno_flash;
}

void 
rflflash_mark_bad(unsigned long from, unsigned long to)
{
  rflflash_init();

  unsigned pagesize   = rflflash_nand_pagesize();
  unsigned blocksize  = our_mtd->erasesize;
  unsigned from_block = from/blocksize;
  unsigned to_block   = to/blocksize;
  unsigned p;
  unsigned b;

  if (!our_mtd->ignore_bad) {
    printf("Error, --nandignorebad must be set to allow --nandmarkbad.\n");
    exit(0);
  }

  for (b=from_block; b<=to_block; b++) {
    printf("mark bad block 0x%x, 0x%8.8x-0x%8.8x\n", b, b*blocksize, ((b+1)*blocksize)-1);
    our_mtd->block_markbad(our_mtd, b*blocksize);
    our_mtd->block_markbad(our_mtd, b*blocksize+pagesize);
  }
  
}

void 
rflflash_ignore_bad()
{
  rflflash_init();

  printf(">rflflash_ignore_bad\n");

  our_mtd->ignore_bad = 1;
}

/* dump nand memory region, addresses are offsets from 0 in nand */

void 
rflflash_dump(unsigned long from, unsigned long to)
{
  unsigned *i = from;
  int j;

  rflflash_init();

  {
    int pagesize       = rflflash_nand_pagesize();
    unsigned blocksize = our_mtd->erasesize;
    unsigned ppb       = blocksize/pagesize; /* pages per block */
    int from_page      = from/pagesize;
    int to_page        = to/pagesize;
    int current_page   = from_page; /* -1 so we get new page immediately */

    while(current_page <= to_page) {
      //printf("new page %d, a=0x%x i=0x%x\n", current_page, current_page*pagesize, i);

      /* New block? Check if it's bad. */
      if ((current_page%ppb) == 0) { 
        unsigned current_block = current_page/ppb;
        //printf("new block %d\n", current_block);

        /* check bad block in first two pages */
        if ((our_mtd->block_isbad(our_mtd, (current_block)*blocksize)) ||
            (our_mtd->block_isbad(our_mtd, (current_block)*blocksize+pagesize))) {
          printf("Skipping bad block 0x%x, 0x%8.8x-0x%8.8x\n", 
                 current_block, 
                 current_block*blocksize, 
                 (current_block+1)*blocksize-1);
          current_page+=ppb;
          i+=(blocksize/4);
          continue;
        }
      }
      
      { /* read page */
        unsigned long foo;
        rflflash_read(current_page*pagesize, data_buf, pagesize, &foo);
        //printf("read 0x%x 0x%x\n", current_page*pagesize, *(int*)data_buf[4]);
      }
      
      {
        unsigned l;
        /* print page */
        for(l=0;l<pagesize && i<to; l+=16, i+=4) {
          /* print one line */
          printf("%8.8x :", i);
          for(j=0; j != 4 && (i+j < to); j++) {
            printf(" %8.8x", *(unsigned*)(data_buf+(((unsigned)i+j*4)-(current_page*pagesize))));
            
          }
          printf("\r\n");
        }
      }
      
      current_page++;
    }
  }
  
}

/* dump oob in memory region, addresses are offsets from 0 in nand */

void 
rflflash_dump_oob(unsigned long from, unsigned long to, unsigned char only_bad)
{
  rflflash_init();

  unsigned pagesize  = rflflash_nand_pagesize();
  unsigned from_page = from/pagesize;
  unsigned to_page   = to/pagesize;
  unsigned blocksize = our_mtd->erasesize;
  unsigned p;
  struct nand_chip *this;
  unsigned badblockpos;
  unsigned char buf[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};


#if 0
  if (only_bad) {
    unsigned i;

    for(i=0; i!=16; i++) {
      rflflash_nand_erase(our_mtd, 0, 500);
      our_mtd->write_oob(our_mtd, i, 1, &p, buf);
      rflflash_dump_oob(0, 1, 0);
    }
  }
#endif

  this = our_mtd->priv;
  badblockpos = this->badblockpos;
  
  for (p=from_page; p<=to_page; p++) {
    size_t ret;

    our_mtd->read_oob(our_mtd, p*pagesize, our_mtd->oobsize, &ret, oob_buf);

    if(only_bad) {
      if(oob_buf[badblockpos-1] == 0xff) {
        continue;
      }
    }

    {
      unsigned ppb = blocksize/pagesize;
        printf("block 0x%x, page 0x%x (0x%x in block), 0x%8.8x-0x%8.8x: ", 
               (p*pagesize)/blocksize, p, p%ppb, p*pagesize, (p+1)*pagesize-1);
    }
    
    {
      unsigned j;
      
      for(j=0; j != our_mtd->oobsize; j++) {
        printf(" %2.2x", oob_buf[j]);
      }
#if 0
      if (our_mtd->block_isbad(our_mtd, p*pagesize)) {
        printf(" BAD");
      }
#endif
      printf("\r\n");
    }
  }
}


/* 
 * Read data from flash to datum (copy size bytes). Returns errno_flash .
 * Limitation: Must read at least 512 bytes, and from start of a page.
 */
unsigned long
rflflash_read (unsigned long offset, unsigned char *datum, 
                           unsigned long size, unsigned long *readlen)
{
        int mtd_err;
        int read = 0;
        //      diag_printf("Read from 0x%x, len 0x%x, to 0x%x\n", offset, size, datum);

        errno_flash = ERROR_RESET;

        if (our_mtd)
        {
                mtd_err = 
                        rflflash_nand_rw(our_mtd, NAND_READ, offset, NO_END_LIMIT, 
                                                     size, &read, NULL, datum);
                if (mtd_err)
                        errno_flash |= ERROR_READ_FAILED;
        }
        else
                errno_flash |= ERROR_NO_CHIP_FOUND;

        if (readlen)
                *readlen = read;
  return errno_flash;
}

/* 
 * Checksum data from flash (size bytes). Returns error code.
 * Limitation: Size must be at least 512 bytes, and from start of a page.
 */
unsigned long
rflflash_checksum (unsigned long offset, unsigned long size, 
                               unsigned long *ret_csum)
{
        int mtd_err;
        unsigned long csum;
        diag_printf("Csum from 0x%x, len 0x%x\n", offset, size);

        errno_flash = ERROR_RESET;

        if (our_mtd)
        {
                mtd_err = 
                        rflflash_nand_rw(our_mtd, NAND_CSUM, offset, NO_END_LIMIT, 
                                                     size, NULL, &csum, NULL);
                if (mtd_err)
                        errno_flash |= ERROR_READ_FAILED;
        }
        else
                errno_flash |= ERROR_NO_CHIP_FOUND;

        if (ret_csum)
                *ret_csum = csum;
  return errno_flash;
}


/* 
 *      hardware specific access to control-lines, via hal nand layer
 */
static void
nand_hwcontrol(struct mtd_info *mtd, int cmd)
{
/* If we're "lucky" and the control values match 1 to 1 ... */
#if (NAND_CTL_SETCLE == NAND_SET_CLE) && \
    (NAND_CTL_CLRCLE == NAND_CLR_CLE) && \
    (NAND_CTL_SETALE == NAND_SET_ALE) && \
    (NAND_CTL_CLRALE == NAND_CLR_ALE) && \
    (NAND_CTL_SETNCE == NAND_SET_NCE) && \
    (NAND_CTL_CLRNCE == NAND_CLR_NCE)
  hal_nand_hwcontrol(cmd); /* call hal function directly */

#else /* map them */
        int halcmd;

        switch (cmd) {
                case NAND_CTL_SETCLE: 
                        halcmd = NAND_SET_CLE;
                        break;
                case NAND_CTL_CLRCLE: 
                        halcmd = NAND_CLR_CLE;
                        break;
                case NAND_CTL_SETALE:
                        halcmd = NAND_SET_ALE;
                        break;
                case NAND_CTL_CLRALE: 
                        halcmd = NAND_CLR_ALE;
                        break;
                case NAND_CTL_SETNCE:
                        halcmd = NAND_SET_NCE;
                        break;
                case NAND_CTL_CLRNCE:
                        halcmd = NAND_CLR_NCE;
                        break;
        }

        hal_nand_hwcontrol(halcmd);
#endif
}


/*
 * Read busy line on flash chip
 */
static int
nand_device_ready(struct mtd_info *mtd)
{
        return hal_nand_device_ready();
}


/*
 * Deduce the number of flash units and the type of each unit.
 * Returns 0 on success, and the bit mask errno_flash on error.
 */
unsigned long
rflflash_init (void)
{
  //printf(">rflflash_init\n");

        if (!our_mtd)
        {
                /* Initialize the hardware */
                hal_nand_init();

                /* Clear structures */
                memset((char *) &mtd_info, 0, sizeof(struct mtd_info));
                memset((char *) &nand_chip, 0, sizeof(struct nand_chip));

                /* Link the private data with the MTD structure */
                mtd_info.priv = &nand_chip;

                /* Set address of NAND IO lines */
                nand_chip.IO_ADDR_R = (void *) NAND_RD_ADDR;
                nand_chip.IO_ADDR_W = (void *) NAND_WR_ADDR;
                nand_chip.hwcontrol = nand_hwcontrol;
                nand_chip.dev_ready = nand_device_ready;
                /* 20 us command delay time */
                nand_chip.chip_delay = 20;              
                nand_chip.eccmode = NAND_ECC_SOFT;
                /* buffers */
                nand_chip.data_buf = data_buf;
                nand_chip.oob_buf = oob_buf;

                /* Enable the following for a flash based bad block table */
//              nand_chip.options = NAND_USE_FLASH_BBT;

                /* don't scan for BBT - we read them on-the-fly */
//              nand_chip.options = NAND_SKIP_BBTSCAN;
                nand_chip.options = NAND_USE_FLASH_BBT;
//              nand_chip.options = 0;

                /* Scan to find existance of the device */
                if (nand_scan(&mtd_info, 1)) {
                        D(diag_printf("rflflash_init(NAND): nand_scan failed\n"));
                }
                else
                {
                  our_mtd = &mtd_info;

                  //D(diag_printf("rflflash_init(NAND): NAND flash detected:\n"));
                  printf("blocksize %d, pagesize %d, oobsize %d, total 0x%8.8x bytes\n",
                         our_mtd->erasesize, our_mtd->oobblock, 
                         our_mtd->oobsize, our_mtd->size);
                }
        }

  return errno_flash;
}

/*
 * Return page size for nand flash in use
 */
unsigned long
rflflash_nand_pagesize(void)
{
        if (our_mtd)
                return our_mtd->oobblock;
        else
                return 1; /* 0 might lead to an infinite loop somewhere */
}

/*
 * Return total size of nand flash in use
 */
unsigned long
rflflash_nand_size(void)
{
        if (our_mtd)
                return our_mtd->size;
        else
                return 0;
}

/*************************** END OF FILE *******************************/

---