os/nandboot-R2_0_4/bootload.c

Go to the documentation of this file.

/*****************************************************************************
*!
*! FILE NAME  : bootload.c
*!
*! DESCRIPTION: Boot loader for NAND chips on ETRAX FS.
*!
*! ---------------------------------------------------------------------------
*! Portions (nand_rw) derived from U-Boot 1.4.4 (common/cmd_nand.c):
*! Driver for NAND support, Rick Bronson
*! borrowed heavily from:
*! (c) 1999 Machine Vision Holdings, Inc.
*! (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
*!
*! Added 16-bit nand support
*! (C) 2004 Texas Instruments
*!
*! Boot loader function
*! (C) Copyright 2006-2007, Axis Communications AB, LUND, SWEDEN
*!
*! This program is free software; you can redistribute it and/or modify
*! it under the terms of the GNU General Public License as published by
*! the Free Software Foundation; either version 2 of the License, or
*! (at your option) any later version.
*!
*! This program is distributed in the hope that it will be useful,
*! but WITHOUT ANY WARRANTY; without even the implied warranty of
*! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*! GNU General Public License for more details.
*!
*! You should have received a copy of the GNU General Public License
*! along with this program; if not, write to the Free Software
*! Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*!
*!***************************************************************************/

#include <linux/types.h>
#include <linux/autoconf.h>

#include "mtd.h"
#include "nand.h"
#include "delay.h"

#include <asm/arch/hwregs/reg_rdwr.h>
#include <asm/arch/hwregs/reg_map.h>
#include <asm/arch/hwregs/pinmux_defs.h>

#include <asm/arch/hwregs/reg_map.h>
#include <asm/arch/hwregs/bif_core_defs.h>
#include <asm/arch/hwregs/gio_defs.h>
#include <asm/arch/hwregs/pinmux_defs.h>

#include "lib.h"

#include "bootconfig.h"

#define BOOTDEBUG 1
#define MORE_BOOTDEBUG 1

/* Control macros for NAND read/write function from U-Boot 1.4.4 */
/* bits for nand_rw() `cmd'; or together as needed */

#define NANDRW_READ             0x01
#define NANDRW_WRITE            0x00
#define NANDRW_JFFS2            0x02
#define NANDRW_JFFS2_SKIP       0x04

#define ROUND_DOWN(value, boundary)      ((value) & (~((boundary)-1)))

/* set $r8 to RAM_INIT_MAGIC, $r12 to NAND_BOOT_MAGIC then jump */
/* multiple macros needed to get the constants into the asm string properly */
#define SET_MAGIC_AND_BOOT(ADDR, MAGIC_R8, MAGIC_R12) \
        __asm__ volatile (" \
        move.d " #MAGIC_R8 ", $r8\n\
        move.d " #MAGIC_R12 ", $r12\n\
        jump %0\n\
        nop\n\
        " : : "r" (ADDR))
#define BOOT1(ADDR, MAGIC_R8, MAGIC_R12) \
        SET_MAGIC_AND_BOOT(ADDR, MAGIC_R8, MAGIC_R12);
#define BOOT(ADDR) \
        BOOT1(ADDR, RAM_INIT_MAGIC, NAND_BOOT_MAGIC);

extern struct mtd_info *crisv32_nand_flash_probe(void);

extern int _end, _bss, _edata;

/*
 * NAND read/write from U-Boot 1.4.4
 * Modified for newer mtd and use of mtd interface instead of nand directly.
 * Note: bad block skipping assumes read starts on a block boundary.
 *
 * cmd: 0: NANDRW_WRITE                 write, fail on bad block
 *      1: NANDRW_READ                  read, fail on bad block
 *      2: NANDRW_WRITE | NANDRW_JFFS2  write, skip bad blocks
 *      3: NANDRW_READ | NANDRW_JFFS2   read, data all 0xff for bad blocks
 *      7: NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP read, skip bad blocks
 */
static int
nand_rw (struct mtd_info* mtd, int cmd,
         size_t start, size_t len,
         size_t *retlen, u_char * buf)
{
        int total = 0;
        int ret = 0;
        int n;

        /* 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;

        putnl();
        while (len) {
                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 BOOTDEBUG
                        puts("New block ");
                        putx(eblk);
                        puts(";len: ");
                        putx(len);
                        puts(";start: ");
                        putx(start);
                        putnl();
#endif
                        /* if block is bad, just skip it, and read next block */
                        if (mtd->block_isbad(mtd, eblk)) {
                                if (cmd == (NANDRW_READ | NANDRW_JFFS2)) {
//                                      len -= erasesize;
                                        start += erasesize;
                                        puts("bad block - skip it ...1");
                                        putnl();
/*
                                        while (len > 0 && start - eblk < erasesize) {
                                                *(buf++) = 0xff;
                                                ++start;
                                                ++total;
                                                --len;
                                        }
*/
                                        continue;
                                } else if (cmd == (NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP)) {
                                        puts("bad block - skip it ...2");
                                        putnl();
                                        start += erasesize;
                                        continue;
                                } else if (cmd == (NANDRW_WRITE | NANDRW_JFFS2)) {
                                        puts("bad block - skip it ...3");
                                        putnl();
                                        /* skip bad block */
                                        start += erasesize;
                                        continue;
                                } else {
                                        puts("bad block - skip it ...4");
                                        putnl();
                                        ret = 1;
                                        break;
                                }
                        }
                }

#if 0
                buf = (void *) 0x38008000; /* to fixed address, for testing */
#endif

                if (cmd & NANDRW_READ) {
                        ret = mtd->read_ecc(mtd, start,
                                            min(len, eblk + erasesize - start),
                                            (size_t *)&n, (u_char*)buf,
                                            NULL, NULL);
                } else {
                        ret = mtd->write_ecc(mtd, start,
                                             min(len, eblk + erasesize - start),
                                             (size_t *)&n, (u_char*)buf,
                                             NULL, NULL);
                }

                if (ret) {
                        break;
                }

                start  += n;
                buf   += n;
                total += n;
                len   -= n;
        }
        if (retlen)
                *retlen = total;

        return ret;
}


void
bootload(void)
{
        char revision;
        struct mtd_info *mtd;
        int res;
        int copied;
#if BOOTDEBUG
        int i;
#endif

        serial_init();

//      *(unsigned long *)REG_ADDR(bif_core, regi_bif_core, rw_grp1_cfg) = CONFIG_ETRAX_MEM_GRP1_CONFIG;
//      *(unsigned long *)REG_ADDR(bif_core, regi_bif_core, rw_grp2_cfg) = CONFIG_ETRAX_MEM_GRP2_CONFIG;
        *(unsigned long *)REG_ADDR(bif_core, regi_bif_core, rw_grp3_cfg) = CONFIG_ETRAX_MEM_GRP3_CONFIG;
//      *(unsigned long *)REG_ADDR(bif_core, regi_bif_core, rw_grp4_cfg) = CONFIG_ETRAX_MEM_GRP4_CONFIG;

        __asm__ volatile ("move $vr,%0" : "=rm" (revision));
        if (revision < 32) {
                error("You need an ETRAX FS to run Linux 2.6/crisv32.\r\n");
                while(1);
        }
        puts("Clear cmdline from memory") ;
        putnl();
        unsigned long *ul_cmdline_ram = (unsigned long *)0xC0004000;
        ul_cmdline_ram[0] = 0x00000000;

#if BOOTDEBUG
        puts("\r\n\nETRAX FS NAND boot loader\r\n");
        puts("=========================\r\n");
        puts("Rev 1, " __DATE__ " " __TIME__ "\r\n");

        puts("Boot config: ");
        putx(FETCH_ADDR);
        puts("->");
        putx(STORE_ADDR);
        puts(", len ");
        putx(LOAD_SIZE);
        puts(", boot @ ");
        putx(BOOT_ADDR);
        putnl();

        puts("CPU revision: ");
        putx(revision);
        putnl();

#if MORE_BOOTDEBUG
        puts("Bootloader main at ") ;
        putx((int) bootload);
        putnl();

        puts("Data end: ");
        putx((long) &_edata);
        putnl();

        puts("Bss: ");
        putx((long) &_bss);
        putnl();

        puts("Heap: ");
        putx((long) &_end);
        putnl();
#endif

        puts("Identifying nand chip...\r\n");
#endif

        mtd = crisv32_nand_flash_probe();

#if BOOTDEBUG
        puts("Done.\r\n");
#endif

        if (!mtd)
                error("No NAND flash chip found to boot from.");

#if BOOTDEBUG
        puts("Chip identified... 3; ");

#if MORE_BOOTDEBUG
        if (mtd->name)
                puts(mtd->name);

        puts("\r\ntype: ");
        putx(mtd->type);
        puts("\r\nflags: ");
        putx(mtd->flags);
        puts("\r\nsize: ");
        putx(mtd->size);
        puts("\r\nerasesize: ");
        putx(mtd->erasesize);
        puts("\r\noobblock: ");
        putx(mtd->oobblock);
        puts("\r\noobsize: ");
        putx(mtd->oobsize);
        puts("\r\necctype: ");
        putx(mtd->ecctype);
        puts("\r\neccsize: ");
        putx(mtd->eccsize);
#endif /* MORE BOOTDEBUG */
        putnl();

/*
        puts("Bad blocks:\r\n");

        for (i = 0; i < mtd->size; i += mtd->erasesize) {
                if (mtd->block_isbad(mtd, i)) {
                        putx(i);
                        putnl();
                }
        }
*/
#endif /* BOOTDEBUG */

#if MORE_BOOTDEBUG /* print oob parameters */
        puts("Oob info:\r\n");
        puts("useecc: ");
        putx(mtd->oobinfo.useecc);
        puts("\r\neccbytes: ");
        putx(mtd->oobinfo.eccbytes);
        puts("\r\neccpos: ");
        for (i = 0; i < mtd->oobinfo.eccbytes; i++) {
                putx(mtd->oobinfo.eccpos[i]);
                putc(' ');
        }
        putnl();
#endif

#if BOOTDEBUG
        puts("Bootload in progress...");
#endif
//      res = 1;
//      while(res) {
//              puts("---> try to read from flash from address: ");
//              putx(FETCH_ADDR);
//              putnl();
        res = nand_rw(mtd,
                      NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP,
                      FETCH_ADDR, LOAD_SIZE, &copied,
                      (void *) STORE_ADDR);
//      }

#if BOOTDEBUG
        puts("complete, status ");
        putx(res);
        puts(", loaded ");
        putx(copied);
        puts(" bytes\r\n");

        puts("Data in DRAM:\r\n");
        putx(* (int *) STORE_ADDR);
        putc(' ');
        putx(* (int *) (STORE_ADDR+4));
        putc(' ');
        putx(* (int *) (STORE_ADDR+8));
        putnl();
#endif

        if (res)
                error("Corrupt data in NAND flash.");

#if BOOTDEBUG
        puts("Booting...\r\n");
#endif

        BOOT(BOOT_ADDR);

        while (1)
                ; /* hang around for a while ... */
}

---