/* * drivers/mtd/nand/nand_util.c * * Copyright (C) 2006 by Weiss-Electronic GmbH. * All rights reserved. * * @author:	Guido Classen <clagix@gmail.com> * @descr:	NAND Flash support * @references: borrowed heavily from Linux mtd-utils code: *		flash_eraseall.c by Arcom Control System Ltd *		nandwrite.c by Steven J. Hill (sjhill@realitydiluted.com) *			       and Thomas Gleixner (tglx@linutronix.de) * * See file CREDITS for list of people who contributed to this * project. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 as published by the Free Software Foundation. * * 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., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * */#include <common.h>#include <command.h>#include <watchdog.h>#include <malloc.h>#include <div64.h>#include <asm/errno.h>#include <linux/mtd/mtd.h>#include <nand.h>#include <jffs2/jffs2.h>typedef struct erase_info erase_info_t;typedef struct mtd_info	  mtd_info_t;/* support only for native endian JFFS2 */#define cpu_to_je16(x) (x)#define cpu_to_je32(x) (x)/*****************************************************************************/static int nand_block_bad_scrub(struct mtd_info *mtd, loff_t ofs, int getchip){	return 0;}/** * nand_erase_opts: - erase NAND flash with support for various options *		      (jffs2 formating) * * @param meminfo	NAND device to erase * @param opts		options,  @see struct nand_erase_options * @return		0 in case of success * * This code is ported from flash_eraseall.c from Linux mtd utils by * Arcom Control System Ltd. */int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts){	struct jffs2_unknown_node cleanmarker;	erase_info_t erase;	ulong erase_length;	int bbtest = 1;	int result;	int percent_complete = -1;	int (*nand_block_bad_old)(struct mtd_info *, loff_t, int) = NULL;	const char *mtd_device = meminfo->name;	struct mtd_oob_ops oob_opts;	struct nand_chip *chip = meminfo->priv;	memset(&erase, 0, sizeof(erase));	memset(&oob_opts, 0, sizeof(oob_opts));	erase.mtd = meminfo;	erase.len  = meminfo->erasesize;	erase.addr = opts->offset;	erase_length = opts->length;	cleanmarker.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);	cleanmarker.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);	cleanmarker.totlen = cpu_to_je32(8);	/* scrub option allows to erase badblock. To prevent internal	 * check from erase() method, set block check method to dummy	 * and disable bad block table while erasing.	 */	if (opts->scrub) {		struct nand_chip *priv_nand = meminfo->priv;		nand_block_bad_old = priv_nand->block_bad;		priv_nand->block_bad = nand_block_bad_scrub;		/* we don't need the bad block table anymore...		 * after scrub, there are no bad blocks left!		 */		if (priv_nand->bbt) {			kfree(priv_nand->bbt);		}		priv_nand->bbt = NULL;	}	if (erase_length < meminfo->erasesize) {		printf("Warning: Erase size 0x%08lx smaller than one "	\		       "erase block 0x%08x\n",erase_length, meminfo->erasesize);		printf("         Erasing 0x%08x instead\n", meminfo->erasesize);		erase_length = meminfo->erasesize;	}	for (;	     erase.addr < opts->offset + erase_length;	     erase.addr += meminfo->erasesize) {		WATCHDOG_RESET ();		if (!opts->scrub && bbtest) {			int ret = meminfo->block_isbad(meminfo, erase.addr);			if (ret > 0) {				if (!opts->quiet)					printf("\rSkipping bad block at  "					       "0x%08x                   "					       "                         \n",					       erase.addr);				continue;			} else if (ret < 0) {				printf("\n%s: MTD get bad block failed: %d\n",				       mtd_device,				       ret);				return -1;			}		}		result = meminfo->erase(meminfo, &erase);		if (result != 0) {			printf("\n%s: MTD Erase failure: %d\n",			       mtd_device, result);			continue;		}		/* format for JFFS2 ? */		if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) {			chip->ops.ooblen = 8;			chip->ops.datbuf = NULL;			chip->ops.oobbuf = (uint8_t *)&cleanmarker;			chip->ops.ooboffs = 0;			chip->ops.mode = MTD_OOB_AUTO;			result = meminfo->write_oob(meminfo,			                            erase.addr,			                            &chip->ops);			if (result != 0) {				printf("\n%s: MTD writeoob failure: %d\n",				       mtd_device, result);				continue;			}		}		if (!opts->quiet) {			unsigned long long n =(unsigned long long)				(erase.addr + meminfo->erasesize - opts->offset)				* 100;			int percent;			do_div(n, erase_length);			percent = (int)n;			/* output progress message only at whole percent			 * steps to reduce the number of messages printed			 * on (slow) serial consoles			 */			if (percent != percent_complete) {				percent_complete = percent;				printf("\rErasing at 0x%x -- %3d%% complete.",				       erase.addr, percent);				if (opts->jffs2 && result == 0)					printf(" Cleanmarker written at 0x%x.",					       erase.addr);			}		}	}	if (!opts->quiet)		printf("\n");	if (nand_block_bad_old) {		struct nand_chip *priv_nand = meminfo->priv;		priv_nand->block_bad = nand_block_bad_old;		priv_nand->scan_bbt(meminfo);	}	return 0;}/* XXX U-BOOT XXX */#if 0#define MAX_PAGE_SIZE	2048#define MAX_OOB_SIZE	64/* * buffer array used for writing data */static unsigned char data_buf[MAX_PAGE_SIZE];static unsigned char oob_buf[MAX_OOB_SIZE];/* OOB layouts to pass into the kernel as default */static struct nand_ecclayout none_ecclayout = {	.useecc = MTD_NANDECC_OFF,};static struct nand_ecclayout jffs2_ecclayout = {	.useecc = MTD_NANDECC_PLACE,	.eccbytes = 6,	.eccpos = { 0, 1, 2, 3, 6, 7 }};static struct nand_ecclayout yaffs_ecclayout = {	.useecc = MTD_NANDECC_PLACE,	.eccbytes = 6,	.eccpos = { 8, 9, 10, 13, 14, 15}};static struct nand_ecclayout autoplace_ecclayout = {	.useecc = MTD_NANDECC_AUTOPLACE};#endif/* XXX U-BOOT XXX */#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK/****************************************************************************** * Support for locking / unlocking operations of some NAND devices *****************************************************************************/#define NAND_CMD_LOCK		0x2a#define NAND_CMD_LOCK_TIGHT	0x2c#define NAND_CMD_UNLOCK1	0x23#define NAND_CMD_UNLOCK2	0x24#define NAND_CMD_LOCK_STATUS	0x7a/** * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT *	      state * * @param mtd		nand mtd instance * @param tight		bring device in lock tight mode * * @return		0 on success, -1 in case of error * * The lock / lock-tight command only applies to the whole chip. To get some * parts of the chip lock and others unlocked use the following sequence: * * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin) * - Call nand_unlock() once for each consecutive area to be unlocked * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1) * *   If the device is in lock-tight state software can't change the *   current active lock/unlock state of all pages. nand_lock() / nand_unlock() *   calls will fail. It is only posible to leave lock-tight state by *   an hardware signal (low pulse on _WP pin) or by power down. */int nand_lock(struct mtd_info *mtd, int tight){	int ret = 0;	int status;	struct nand_chip *chip = mtd->priv;	/* select the NAND device */	chip->select_chip(mtd, 0);	chip->cmdfunc(mtd,		      (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),		      -1, -1);	/* call wait ready function */	status = chip->waitfunc(mtd, chip);	/* see if device thinks it succeeded */	if (status & 0x01) {		ret = -1;	}	/* de-select the NAND device */	chip->select_chip(mtd, -1);	return ret;}/** * nand_get_lock_status: - query current lock state from one page of NAND *			   flash *