Eric Lee / smarc-uboot | Embedian Git Server

Browse Code »

Commit d9831893ab2efd3dd36f948da898c83f33c4992c

Authored by Wolfgang Denk 2006-10-29 07:12:53 +0800

2 parents 1954be6e9c fae684e898

Exists in master and in 54 other branches

Merge with /home/sr/git/u-boot/nand-ladis

Showing 8 changed files Inline Diff

board/netstar/netstar.c
board/voiceblue/voiceblue.c
common/cmd_jffs2.c
common/cmd_nand.c
cpu/arm925t/omap925.c
doc/README.nand
drivers/nand/nand_util.c
include/arm925t.h

board/netstar/netstar.c

Diff comments View file @ d983189

board/voiceblue/voiceblue.c

Diff comments View file @ d983189

 /*
  * (C) Copyright 2005 2N TELEKOMUNIKACE, Ladislav Michl
  *
  * 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>
 DECLARE_GLOBAL_DATA_PTR;
 int board_init(void)
 {
 	*((volatile unsigned char *) VOICEBLUE_LED_REG) = 0xaa;
 	/* arch number of VoiceBlue board */
-	/* TODO: use define from asm/mach-types.h */
+	gd->bd->bi_arch_number = MACH_TYPE_VOICEBLUE;
-	gd->bd->bi_arch_number = 218;
 	/* adress of boot parameters */
 	gd->bd->bi_boot_params = 0x10000100;
 	return 0;
 }
 int dram_init(void)
 {
 	*((volatile unsigned short *) VOICEBLUE_LED_REG) = 0xff;
- 	/* Take the Ethernet controller out of reset and wait
+	/* Take the Ethernet controller out of reset and wait
- 	 * for the EEPROM load to complete. */
+	 * for the EEPROM load to complete. */
 	*((volatile unsigned short *) GPIO_DATA_OUTPUT_REG) |= 0x80;
 	udelay(10);	/* doesn't work before interrupt_init call */
 	*((volatile unsigned short *) GPIO_DATA_OUTPUT_REG) &= ~0x80;
 	udelay(500);
 	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
 	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
 	return 0;
 }
 int misc_init_r(void)
 {
 	*((volatile unsigned short *) VOICEBLUE_LED_REG) = 0x55;
 	return 0;
 }
 int board_late_init(void)
 {
 	*((volatile unsigned char *) VOICEBLUE_LED_REG) = 0x00;
 	return 0;
 }

common/cmd_jffs2.c

Diff comments View file @ d983189

 /*
  * (C) Copyright 2002
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * (C) Copyright 2002
  * Robert Schwebel, Pengutronix, <r.schwebel@pengutronix.de>
  *
  * (C) Copyright 2003
  * Kai-Uwe Bloem, Auerswald GmbH & Co KG, <linux-development@auerswald.de>
  *
  * (C) Copyright 2005
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  *   Added support for reading flash partition table from environment.
  *   Parsing routines are based on driver/mtd/cmdline.c from the linux 2.4
  *   kernel tree.
  *
  *   $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $
  *   Copyright 2002 SYSGO Real-Time Solutions GmbH
  *
  * 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 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., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 /*
  * Three environment variables are used by the parsing routines:
  *
  * 'partition' - keeps current partition identifier
  *
  * partition  := <part-id>
  * <part-id>  := <dev-id>,part_num
  *
  *
  * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping
  *
  * mtdids=<idmap>[,<idmap>,...]
  *
  * <idmap>    := <dev-id>=<mtd-id>
  * <dev-id>   := 'nand'|'nor'<dev-num>
  * <dev-num>  := mtd device number, 0...
  * <mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)
  *
  *
  * 'mtdparts' - partition list
  *
  * mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]
  *
  * <mtd-def>  := <mtd-id>:<part-def>[,<part-def>...]
  * <mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)
  * <part-def> := <size>[@<offset>][<name>][<ro-flag>]
  * <size>     := standard linux memsize OR '-' to denote all remaining space
  * <offset>   := partition start offset within the device
  * <name>     := '(' NAME ')'
  * <ro-flag>  := when set to 'ro' makes partition read-only (not used, passed to kernel)
  *
  * Notes:
  * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping
  * - if the above variables are not set defaults for a given target are used
  *
  * Examples:
  *
  * 1 NOR Flash, with 1 single writable partition:
  * mtdids=nor0=edb7312-nor
  * mtdparts=mtdparts=edb7312-nor:-
  *
  * 1 NOR Flash with 2 partitions, 1 NAND with one
  * mtdids=nor0=edb7312-nor,nand0=edb7312-nand
  * mtdparts=mtdparts=edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home)
  *
  */
 /*
  * JFFS2/CRAMFS support
  */
 #include <common.h>
 #include <command.h>
 #include <malloc.h>
 #include <jffs2/jffs2.h>
 #include <linux/list.h>
 #include <linux/ctype.h>
 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2)
 #include <cramfs/cramfs_fs.h>
 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
 #ifdef CFG_NAND_LEGACY
 #include <linux/mtd/nand_legacy.h>
 #else /* !CFG_NAND_LEGACY */
 #include <linux/mtd/nand.h>
 #include <nand.h>
 #endif /* !CFG_NAND_LEGACY */
 #endif /* (CONFIG_COMMANDS & CFG_CMD_NAND) */
 /* enable/disable debugging messages */
 #define	DEBUG_JFFS
 #undef	DEBUG_JFFS
 #ifdef  DEBUG_JFFS
 # define DEBUGF(fmt, args...)	printf(fmt ,##args)
 #else
 # define DEBUGF(fmt, args...)
 #endif
 /* special size referring to all the remaining space in a partition */
 #define SIZE_REMAINING		0xFFFFFFFF
 /* special offset value, it is used when not provided by user
  *
  * this value is used temporarily during parsing, later such offests
  * are recalculated */
 #define OFFSET_NOT_SPECIFIED	0xFFFFFFFF
 /* minimum partition size */
 #define MIN_PART_SIZE		4096
 /* this flag needs to be set in part_info struct mask_flags
  * field for read-only partitions */
 #define MTD_WRITEABLE_CMD		1
 #ifdef CONFIG_JFFS2_CMDLINE
 /* default values for mtdids and mtdparts variables */
 #if defined(MTDIDS_DEFAULT)
 static const char *const mtdids_default = MTDIDS_DEFAULT;
 #else
 #warning "MTDIDS_DEFAULT not defined!"
 static const char *const mtdids_default = NULL;
 #endif
 #if defined(MTDPARTS_DEFAULT)
 static const char *const mtdparts_default = MTDPARTS_DEFAULT;
 #else
 #warning "MTDPARTS_DEFAULT not defined!"
 static const char *const mtdparts_default = NULL;
 #endif
 /* copies of last seen 'mtdids', 'mtdparts' and 'partition' env variables */
 #define MTDIDS_MAXLEN		128
 #define MTDPARTS_MAXLEN		512
 #define PARTITION_MAXLEN	16
 static char last_ids[MTDIDS_MAXLEN];
 static char last_parts[MTDPARTS_MAXLEN];
 static char last_partition[PARTITION_MAXLEN];
 /* low level jffs2 cache cleaning routine */
 extern void jffs2_free_cache(struct part_info *part);
 /* mtdids mapping list, filled by parse_ids() */
 struct list_head mtdids;
 /* device/partition list, parse_cmdline() parses into here */
 struct list_head devices;
 #endif /* #ifdef CONFIG_JFFS2_CMDLINE */
 /* current active device and partition number */
 static struct mtd_device *current_dev = NULL;
 static u8 current_partnum = 0;
 extern int cramfs_check (struct part_info *info);
 extern int cramfs_load (char *loadoffset, struct part_info *info, char *filename);
 extern int cramfs_ls (struct part_info *info, char *filename);
 extern int cramfs_info (struct part_info *info);
 static struct part_info* jffs2_part_info(struct mtd_device *dev, unsigned int part_num);
 /* command line only routines */
 #ifdef CONFIG_JFFS2_CMDLINE
 static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len);
 static int device_del(struct mtd_device *dev);
 /**
  * Parses a string into a number.  The number stored at ptr is
  * potentially suffixed with K (for kilobytes, or 1024 bytes),
  * M (for megabytes, or 1048576 bytes), or G (for gigabytes, or
  * 1073741824).  If the number is suffixed with K, M, or G, then
  * the return value is the number multiplied by one kilobyte, one
  * megabyte, or one gigabyte, respectively.
  *
  * @param ptr where parse begins
  * @param retptr output pointer to next char after parse completes (output)
  * @return resulting unsigned int
  */
 static unsigned long memsize_parse (const char *const ptr, const char **retptr)
 {
 	unsigned long ret = simple_strtoul(ptr, (char **)retptr, 0);
 	switch (**retptr) {
 		case 'G':
 		case 'g':
 			ret <<= 10;
 		case 'M':
 		case 'm':
 			ret <<= 10;
 		case 'K':
 		case 'k':
 			ret <<= 10;
 			(*retptr)++;
 		default:
 			break;
 	}
 	return ret;
 }
 /**
  * Format string describing supplied size. This routine does the opposite job
  * to memsize_parse(). Size in bytes is converted to string and if possible
  * shortened by using k (kilobytes), m (megabytes) or g (gigabytes) suffix.
  *
  * Note, that this routine does not check for buffer overflow, it's the caller
  * who must assure enough space.
  *
  * @param buf output buffer
  * @param size size to be converted to string
  */
 static void memsize_format(char *buf, u32 size)
 {
 #define SIZE_GB ((u32)1024*1024*1024)
 #define SIZE_MB ((u32)1024*1024)
 #define SIZE_KB ((u32)1024)
 	if ((size % SIZE_GB) == 0)
 		sprintf(buf, "%lug", size/SIZE_GB);
 	else if ((size % SIZE_MB) == 0)
 		sprintf(buf, "%lum", size/SIZE_MB);
 	else if (size % SIZE_KB == 0)
 		sprintf(buf, "%luk", size/SIZE_KB);
 	else
 		sprintf(buf, "%lu", size);
 }
 /**
  * This routine does global indexing of all partitions. Resulting index for
  * current partition is saved in 'mtddevnum'. Current partition name in
  * 'mtddevname'.
  */
 static void index_partitions(void)
 {
 	char buf[16];
 	u16 mtddevnum;
 	struct part_info *part;
 	struct list_head *dentry;
 	struct mtd_device *dev;
 	DEBUGF("--- index partitions ---\n");
 	if (current_dev) {
 		mtddevnum = 0;
 		list_for_each(dentry, &devices) {
 			dev = list_entry(dentry, struct mtd_device, link);
 			if (dev == current_dev) {
 				mtddevnum += current_partnum;
 				sprintf(buf, "%d", mtddevnum);
 				setenv("mtddevnum", buf);
 				break;
 			}
 			mtddevnum += dev->num_parts;
 		}
 		part = jffs2_part_info(current_dev, current_partnum);
 		setenv("mtddevname", part->name);
 		DEBUGF("=> mtddevnum %d,\n=> mtddevname %s\n", mtddevnum, part->name);
 	} else {
 		setenv("mtddevnum", NULL);
 		setenv("mtddevname", NULL);
 		DEBUGF("=> mtddevnum NULL\n=> mtddevname NULL\n");
 	}
 }
 /**
  * Save current device and partition in environment variable 'partition'.
  */
 static void current_save(void)
 {
 	char buf[16];
 	DEBUGF("--- current_save ---\n");
 	if (current_dev) {
 		sprintf(buf, "%s%d,%d", MTD_DEV_TYPE(current_dev->id->type),
 					current_dev->id->num, current_partnum);
 		setenv("partition", buf);
 		strncpy(last_partition, buf, 16);
 		DEBUGF("=> partition %s\n", buf);
 	} else {
 		setenv("partition", NULL);
 		last_partition[0] = '\0';
 		DEBUGF("=> partition NULL\n");
 	}
 	index_partitions();
 }
 /**
  * Performs sanity check for supplied NOR flash partition. Table of existing
  * NOR flash devices is searched and partition device is located. Alignment
  * with the granularity of NOR flash sectors is verified.
  *
  * @param id of the parent device
  * @param part partition to validate
  * @return 0 if partition is valid, 1 otherwise
  */
 static int part_validate_nor(struct mtdids *id, struct part_info *part)
 {
 #if (CONFIG_COMMANDS & CFG_CMD_FLASH)
 	/* info for FLASH chips */
 	extern flash_info_t flash_info[];
 	flash_info_t *flash;
 	int offset_aligned;
 	u32 end_offset;
 	int i;
 	flash = &flash_info[id->num];
 	offset_aligned = 0;
 	for (i = 0; i < flash->sector_count; i++) {
 		if ((flash->start[i] - flash->start[0]) == part->offset) {
 			offset_aligned = 1;
 			break;
 		}
 	}
 	if (offset_aligned == 0) {
 		printf("%s%d: partition (%s) start offset alignment incorrect\n",
 				MTD_DEV_TYPE(id->type), id->num, part->name);
 		return 1;
 	}
 	end_offset = part->offset + part->size;
 	for (i = 0; i < flash->sector_count; i++) {
 		if ((flash->start[i] - flash->start[0]) == end_offset)
 			return 0;
 	}
 	if (flash->size == end_offset)
 		return 0;
 	printf("%s%d: partition (%s) size alignment incorrect\n",
 			MTD_DEV_TYPE(id->type), id->num, part->name);
 #endif
 	return 1;
 }
 /**
  * Performs sanity check for supplied NAND flash partition. Table of existing
  * NAND flash devices is searched and partition device is located. Alignment
  * with the granularity of nand erasesize is verified.
  *
  * @param id of the parent device
  * @param part partition to validate
  * @return 0 if partition is valid, 1 otherwise
  */
 static int part_validate_nand(struct mtdids *id, struct part_info *part)
 {
 #if defined(CONFIG_JFFS2_NAND) && (CONFIG_COMMANDS & CFG_CMD_NAND)
 	/* info for NAND chips */
 	nand_info_t *nand;
 	nand = &nand_info[id->num];
 	if ((unsigned long)(part->offset) % nand->erasesize) {
 		printf("%s%d: partition (%s) start offset alignment incorrect\n",
 				MTD_DEV_TYPE(id->type), id->num, part->name);
 		return 1;
 	}
 	if (part->size % nand->erasesize) {
 		printf("%s%d: partition (%s) size alignment incorrect\n",
 				MTD_DEV_TYPE(id->type), id->num, part->name);
 		return 1;
 	}
 	return 0;
 #else
 	return 1;
 #endif
 }
 /**
  * Performs sanity check for supplied partition. Offset and size are verified
  * to be within valid range. Partition type is checked and either
  * parts_validate_nor() or parts_validate_nand() is called with the argument
  * of part.
  *
  * @param id of the parent device
  * @param part partition to validate
  * @return 0 if partition is valid, 1 otherwise
  */
 static int part_validate(struct mtdids *id, struct part_info *part)
 {
 	if (part->size == SIZE_REMAINING)
 		part->size = id->size - part->offset;
 	if (part->offset > id->size) {
 		printf("%s: offset %08lx beyond flash size %08lx\n",
 				id->mtd_id, part->offset, id->size);
 		return 1;
 	}
 	if ((part->offset + part->size) <= part->offset) {
 		printf("%s%d: partition (%s) size too big\n",
 				MTD_DEV_TYPE(id->type), id->num, part->name);
 		return 1;
 	}
 	if (part->offset + part->size > id->size) {
 		printf("%s: partitioning exceeds flash size\n", id->mtd_id);
 		return 1;
 	}
 	if (id->type == MTD_DEV_TYPE_NAND)
 		return part_validate_nand(id, part);
 	else if (id->type == MTD_DEV_TYPE_NOR)
 		return part_validate_nor(id, part);
 	else
 		DEBUGF("part_validate: invalid dev type\n");
 	return 1;
 }
 /**
  * Delete selected partition from the partion list of the specified device.
  *
  * @param dev device to delete partition from
  * @param part partition to delete
  * @return 0 on success, 1 otherwise
  */
 static int part_del(struct mtd_device *dev, struct part_info *part)
 {
 	u8 current_save_needed = 0;
 	/* if there is only one partition, remove whole device */
 	if (dev->num_parts == 1)
 		return device_del(dev);
 	/* otherwise just delete this partition */
 	if (dev == current_dev) {
 		/* we are modyfing partitions for the current device,
 		 * update current */
 		struct part_info *curr_pi;
 		curr_pi = jffs2_part_info(current_dev, current_partnum);
 		if (curr_pi) {
 			if (curr_pi == part) {
 				printf("current partition deleted, resetting current to 0\n");
 				current_partnum = 0;
 			} else if (part->offset <= curr_pi->offset) {
 				current_partnum--;
 			}
 			current_save_needed = 1;
 		}
 	}
 #ifdef CFG_NAND_LEGACY
 	jffs2_free_cache(part);
 #endif
 	list_del(&part->link);
 	free(part);
 	dev->num_parts--;
 	if (current_save_needed > 0)
 		current_save();
 	else
 		index_partitions();
 	return 0;
 }
 /**
  * Delete all partitions from parts head list, free memory.
  *
  * @param head list of partitions to delete
  */
 static void part_delall(struct list_head *head)
 {
 	struct list_head *entry, *n;
 	struct part_info *part_tmp;
 	/* clean tmp_list and free allocated memory */
 	list_for_each_safe(entry, n, head) {
 		part_tmp = list_entry(entry, struct part_info, link);
 #ifdef CFG_NAND_LEGACY
 		jffs2_free_cache(part_tmp);
 #endif
 		list_del(entry);
 		free(part_tmp);
 	}
 }
 /**
  * Add new partition to the supplied partition list. Make sure partitions are
  * sorted by offset in ascending order.
  *
  * @param head list this partition is to be added to
  * @param new partition to be added
  */
 static int part_sort_add(struct mtd_device *dev, struct part_info *part)
 {
 	struct list_head *entry;
 	struct part_info *new_pi, *curr_pi;
 	/* link partition to parrent dev */
 	part->dev = dev;
 	if (list_empty(&dev->parts)) {
 		DEBUGF("part_sort_add: list empty\n");
 		list_add(&part->link, &dev->parts);
 		dev->num_parts++;
 		index_partitions();
 		return 0;
 	}
 	new_pi = list_entry(&part->link, struct part_info, link);
 	/* get current partition info if we are updating current device */
 	curr_pi = NULL;
 	if (dev == current_dev)
 		curr_pi = jffs2_part_info(current_dev, current_partnum);
 	list_for_each(entry, &dev->parts) {
 		struct part_info *pi;
 		pi = list_entry(entry, struct part_info, link);
 		/* be compliant with kernel cmdline, allow only one partition at offset zero */
 		if ((new_pi->offset == pi->offset) && (pi->offset == 0)) {
 			printf("cannot add second partition at offset 0\n");
 			return 1;
 		}
 		if (new_pi->offset <= pi->offset) {
 			list_add_tail(&part->link, entry);
 			dev->num_parts++;
 			if (curr_pi && (pi->offset <= curr_pi->offset)) {
 				/* we are modyfing partitions for the current
 				 * device, update current */
 				current_partnum++;
 				current_save();
 			} else {
 				index_partitions();
 			}
 			return 0;
 		}
 	}
 	list_add_tail(&part->link, &dev->parts);
 	dev->num_parts++;
 	index_partitions();
 	return 0;
 }
 /**
  * Add provided partition to the partition list of a given device.
  *
  * @param dev device to which partition is added
  * @param part partition to be added
  * @return 0 on success, 1 otherwise
  */
 static int part_add(struct mtd_device *dev, struct part_info *part)
 {
 	/* verify alignment and size */
 	if (part_validate(dev->id, part) != 0)
 		return 1;
 	/* partition is ok, add it to the list */
 	if (part_sort_add(dev, part) != 0)
 		return 1;
 	return 0;
 }
 /**
  * Parse one partition definition, allocate memory and return pointer to this
  * location in retpart.
  *
  * @param partdef pointer to the partition definition string i.e. <part-def>
  * @param ret output pointer to next char after parse completes (output)
  * @param retpart pointer to the allocated partition (output)
  * @return 0 on success, 1 otherwise
  */
 static int part_parse(const char *const partdef, const char **ret, struct part_info **retpart)
 {
 	struct part_info *part;
 	unsigned long size;
 	unsigned long offset;
 	const char *name;
 	int name_len;
 	unsigned int mask_flags;
 	const char *p;
 	p = partdef;
 	*retpart = NULL;
 	*ret = NULL;
 	/* fetch the partition size */
 	if (*p == '-') {
 		/* assign all remaining space to this partition */
 		DEBUGF("'-': remaining size assigned\n");
 		size = SIZE_REMAINING;
 		p++;
 	} else {
 		size = memsize_parse(p, &p);
 		if (size < MIN_PART_SIZE) {
 			printf("partition size too small (%lx)\n", size);
 			return 1;
 		}
 	}
 	/* check for offset */
 	offset = OFFSET_NOT_SPECIFIED;
 	if (*p == '@') {
 		p++;
 		offset = memsize_parse(p, &p);
 	}
 	/* now look for the name */
 	if (*p == '(') {
 		name = ++p;
 		if ((p = strchr(name, ')')) == NULL) {
 			printf("no closing ) found in partition name\n");
 			return 1;
 		}
 		name_len = p - name + 1;
 		if ((name_len - 1) == 0) {
 			printf("empty partition name\n");
 			return 1;
 		}
 		p++;
 	} else {
 		/* 0x00000000@0x00000000 */
 		name_len = 22;
 		name = NULL;
 	}
 	/* test for options */
 	mask_flags = 0;
 	if (strncmp(p, "ro", 2) == 0) {
 		mask_flags |= MTD_WRITEABLE_CMD;
 		p += 2;
 	}
 	/* check for next partition definition */
 	if (*p == ',') {
 		if (size == SIZE_REMAINING) {
 			*ret = NULL;
 			printf("no partitions allowed after a fill-up partition\n");
 			return 1;
 		}
 		*ret = ++p;
 	} else if ((*p == ';') || (*p == '\0')) {
 		*ret = p;
 	} else {
 		printf("unexpected character '%c' at the end of partition\n", *p);
 		*ret = NULL;
 		return 1;
 	}
 	/*  allocate memory */
 	part = (struct part_info *)malloc(sizeof(struct part_info) + name_len);
 	if (!part) {
 		printf("out of memory\n");
 		return 1;
 	}
 	memset(part, 0, sizeof(struct part_info) + name_len);
 	part->size = size;
 	part->offset = offset;
 	part->mask_flags = mask_flags;
 	part->name = (char *)(part + 1);
 	if (name) {
 		/* copy user provided name */
 		strncpy(part->name, name, name_len - 1);
 		part->auto_name = 0;
 	} else {
 		/* auto generated name in form of size@offset */
 		sprintf(part->name, "0x%08lx@0x%08lx", size, offset);
 		part->auto_name = 1;
 	}
 	part->name[name_len - 1] = '\0';
 	INIT_LIST_HEAD(&part->link);
 	DEBUGF("+ partition: name %-22s size 0x%08x offset 0x%08x mask flags %d\n",
 			part->name, part->size,
 			part->offset, part->mask_flags);
 	*retpart = part;
 	return 0;
 }
 #endif/* #ifdef CONFIG_JFFS2_CMDLINE */
 /**
  * Check device number to be within valid range for given device type.
  *
  * @param dev device to validate
  * @return 0 if device is valid, 1 otherwise
  */
 static int device_validate(u8 type, u8 num, u32 *size)
 {
 	if (type == MTD_DEV_TYPE_NOR) {
 #if (CONFIG_COMMANDS & CFG_CMD_FLASH)
 		if (num < CFG_MAX_FLASH_BANKS) {
 			extern flash_info_t flash_info[];
 			*size = flash_info[num].size;
 			return 0;
 		}
 		printf("no such FLASH device: %s%d (valid range 0 ... %d\n",
 				MTD_DEV_TYPE(type), num, CFG_MAX_FLASH_BANKS - 1);
 #else
 		printf("support for FLASH devices not present\n");
 #endif
 	} else if (type == MTD_DEV_TYPE_NAND) {
 #if defined(CONFIG_JFFS2_NAND) && (CONFIG_COMMANDS & CFG_CMD_NAND)
 		if (num < CFG_MAX_NAND_DEVICE) {
 #ifndef CFG_NAND_LEGACY
 			*size = nand_info[num].size;
 #else
 			extern struct nand_chip nand_dev_desc[CFG_MAX_NAND_DEVICE];
 			*size = nand_dev_desc[num].totlen;
 #endif
 			return 0;
 		}
 		printf("no such NAND device: %s%d (valid range 0 ... %d)\n",
 				MTD_DEV_TYPE(type), num, CFG_MAX_NAND_DEVICE - 1);
 #else
 		printf("support for NAND devices not present\n");
 #endif
 	}
 	return 1;
 }
 #ifdef CONFIG_JFFS2_CMDLINE
 /**
  * Delete all mtd devices from a supplied devices list, free memory allocated for
  * each device and delete all device partitions.
  *
  * @return 0 on success, 1 otherwise
  */
 static int device_delall(struct list_head *head)
 {
 	struct list_head *entry, *n;
 	struct mtd_device *dev_tmp;
 	/* clean devices list */
 	list_for_each_safe(entry, n, head) {
 		dev_tmp = list_entry(entry, struct mtd_device, link);
 		list_del(entry);
 		part_delall(&dev_tmp->parts);
 		free(dev_tmp);
 	}
 	INIT_LIST_HEAD(&devices);
 	return 0;
 }
 /**
  * If provided device exists it's partitions are deleted, device is removed
  * from device list and device memory is freed.
  *
  * @param dev device to be deleted
  * @return 0 on success, 1 otherwise
  */
 static int device_del(struct mtd_device *dev)
 {
 	part_delall(&dev->parts);
 	list_del(&dev->link);
 	free(dev);
 	if (dev == current_dev) {
 		/* we just deleted current device */
 		if (list_empty(&devices)) {
 			current_dev = NULL;
 		} else {
 			/* reset first partition from first dev from the
 			 * devices list as current */
 			current_dev = list_entry(devices.next, struct mtd_device, link);
 			current_partnum = 0;
 		}
 		current_save();
 		return 0;
 	}
 	index_partitions();
 	return 0;
 }
 /**
  * Search global device list and return pointer to the device of type and num
  * specified.
  *
  * @param type device type
  * @param num device number
  * @return NULL if requested device does not exist
  */
 static struct mtd_device* device_find(u8 type, u8 num)
 {
 	struct list_head *entry;
 	struct mtd_device *dev_tmp;
 	list_for_each(entry, &devices) {
 		dev_tmp = list_entry(entry, struct mtd_device, link);
 		if ((dev_tmp->id->type == type) && (dev_tmp->id->num == num))
 			return dev_tmp;
 	}
 	return NULL;
 }
 /**
  * Add specified device to the global device list.
  *
  * @param dev device to be added
  */
 static void device_add(struct mtd_device *dev)
 {
 	u8 current_save_needed = 0;
 	if (list_empty(&devices)) {
 		current_dev = dev;
 		current_partnum = 0;
 		current_save_needed = 1;
 	}
 	list_add_tail(&dev->link, &devices);
 	if (current_save_needed > 0)
 		current_save();
 	else
 		index_partitions();
 }
 /**
  * Parse device type, name and mtd-id. If syntax is ok allocate memory and
  * return pointer to the device structure.
  *
  * @param mtd_dev pointer to the device definition string i.e. <mtd-dev>
  * @param ret output pointer to next char after parse completes (output)
  * @param retdev pointer to the allocated device (output)
  * @return 0 on success, 1 otherwise
  */
 static int device_parse(const char *const mtd_dev, const char **ret, struct mtd_device **retdev)
 {
 	struct mtd_device *dev;
 	struct part_info *part;
 	struct mtdids *id;
 	const char *mtd_id;
 	unsigned int mtd_id_len;
 	const char *p, *pend;
 	LIST_HEAD(tmp_list);
 	struct list_head *entry, *n;
 	u16 num_parts;
 	u32 offset;
 	int err = 1;
 	p = mtd_dev;
 	*retdev = NULL;
 	*ret = NULL;
 	DEBUGF("===device_parse===\n");
 	/* fetch <mtd-id> */
 	mtd_id = p;
 	if (!(p = strchr(mtd_id, ':'))) {
 		printf("no <mtd-id> identifier\n");
 		return 1;
 	}
 	mtd_id_len = p - mtd_id + 1;
 	p++;
 	/* verify if we have a valid device specified */
 	if ((id = id_find_by_mtd_id(mtd_id, mtd_id_len - 1)) == NULL) {
 		printf("invalid mtd device '%.*s'\n", mtd_id_len - 1, mtd_id);
 		return 1;
 	}
 	DEBUGF("dev type = %d (%s), dev num = %d, mtd-id = %s\n",
 			id->type, MTD_DEV_TYPE(id->type),
 			id->num, id->mtd_id);
 	pend = strchr(p, ';');
 	DEBUGF("parsing partitions %.*s\n", (pend ? pend - p : strlen(p)), p);
 	/* parse partitions */
 	num_parts = 0;
 	offset = 0;
 	if ((dev = device_find(id->type, id->num)) != NULL) {
 		/* if device already exists start at the end of the last partition */
 		part = list_entry(dev->parts.prev, struct part_info, link);
 		offset = part->offset + part->size;
 	}
 	while (p && (*p != '\0') && (*p != ';')) {
 		err = 1;
 		if ((part_parse(p, &p, &part) != 0) || (!part))
 			break;
 		/* calculate offset when not specified */
 		if (part->offset == OFFSET_NOT_SPECIFIED)
 			part->offset = offset;
 		else
 			offset = part->offset;
 		/* verify alignment and size */
 		if (part_validate(id, part) != 0)
 			break;
 		offset += part->size;
 		/* partition is ok, add it to the list */
 		list_add_tail(&part->link, &tmp_list);
 		num_parts++;
 		err = 0;
 	}
 	if (err == 1) {
 		part_delall(&tmp_list);
 		return 1;
 	}
 	if (num_parts == 0) {
 		printf("no partitions for device %s%d (%s)\n",
 				MTD_DEV_TYPE(id->type), id->num, id->mtd_id);
 		return 1;
 	}
 	DEBUGF("\ntotal partitions: %d\n", num_parts);
 	/* check for next device presence */
 	if (p) {
 		if (*p == ';') {
 			*ret = ++p;
 		} else if (*p == '\0') {
 			*ret = p;
 		} else {
 			printf("unexpected character '%c' at the end of device\n", *p);
 			*ret = NULL;
 			return 1;
 		}
 	}
 	/* allocate memory for mtd_device structure */
 	if ((dev = (struct mtd_device *)malloc(sizeof(struct mtd_device))) == NULL) {
 		printf("out of memory\n");
 		return 1;
 	}
 	memset(dev, 0, sizeof(struct mtd_device));
 	dev->id = id;
 	dev->num_parts = 0; /* part_sort_add increments num_parts */
 	INIT_LIST_HEAD(&dev->parts);
 	INIT_LIST_HEAD(&dev->link);
 	/* move partitions from tmp_list to dev->parts */
 	list_for_each_safe(entry, n, &tmp_list) {
 		part = list_entry(entry, struct part_info, link);
 		list_del(entry);
 		if (part_sort_add(dev, part) != 0) {
 			device_del(dev);
 			return 1;
 		}
 	}
 	*retdev = dev;
 	DEBUGF("===\n\n");
 	return 0;
 }
 /**
  * Initialize global device list.
  *
  * @return 0 on success, 1 otherwise
  */
 static int devices_init(void)
 {
 	last_parts[0] = '\0';
 	current_dev = NULL;
 	current_save();
 	return device_delall(&devices);
 }
 /*
  * Search global mtdids list and find id of requested type and number.
  *
  * @return pointer to the id if it exists, NULL otherwise
  */
 static struct mtdids* id_find(u8 type, u8 num)
 {
 	struct list_head *entry;
 	struct mtdids *id;
 	list_for_each(entry, &mtdids) {
 		id = list_entry(entry, struct mtdids, link);
 		if ((id->type == type) && (id->num == num))
 			return id;
 	}
 	return NULL;
 }
 /**
  * Search global mtdids list and find id of a requested mtd_id.
  *
  * Note: first argument is not null terminated.
  *
  * @param mtd_id string containing requested mtd_id
  * @param mtd_id_len length of supplied mtd_id
  * @return pointer to the id if it exists, NULL otherwise
  */
 static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len)
 {
 	struct list_head *entry;
 	struct mtdids *id;
 	DEBUGF("--- id_find_by_mtd_id: '%.*s' (len = %d)\n",
 			mtd_id_len, mtd_id, mtd_id_len);
 	list_for_each(entry, &mtdids) {
 		id = list_entry(entry, struct mtdids, link);
 		DEBUGF("entry: '%s' (len = %d)\n",
 				id->mtd_id, strlen(id->mtd_id));
 		if (mtd_id_len != strlen(id->mtd_id))
 			continue;
 		if (strncmp(id->mtd_id, mtd_id, mtd_id_len) == 0)
 			return id;
 	}
 	return NULL;
 }
 #endif /* #ifdef CONFIG_JFFS2_CMDLINE */
 /**
  * Parse device id string <dev-id> := 'nand'|'nor'<dev-num>, return device
  * type and number.
  *
  * @param id string describing device id
  * @param ret_id output pointer to next char after parse completes (output)
  * @param dev_type parsed device type (output)
  * @param dev_num parsed device number (output)
  * @return 0 on success, 1 otherwise
  */
 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num)
 {
 	const char *p = id;
 	*dev_type = 0;
 	if (strncmp(p, "nand", 4) == 0) {
 		*dev_type = MTD_DEV_TYPE_NAND;
 		p += 4;
 	} else if (strncmp(p, "nor", 3) == 0) {
 		*dev_type = MTD_DEV_TYPE_NOR;
 		p += 3;
 	} else {
 		printf("incorrect device type in %s\n", id);
 		return 1;
 	}
 	if (!isdigit(*p)) {
 		printf("incorrect device number in %s\n", id);
 		return 1;
 	}
 	*dev_num = simple_strtoul(p, (char **)&p, 0);
 	if (ret_id)
 		*ret_id = p;
 	return 0;
 }
 #ifdef CONFIG_JFFS2_CMDLINE
 /**
  * Process all devices and generate corresponding mtdparts string describing
  * all partitions on all devices.
  *
  * @param buf output buffer holding generated mtdparts string (output)
  * @param buflen buffer size
  * @return 0 on success, 1 otherwise
  */
 static int generate_mtdparts(char *buf, u32 buflen)
 {
 	struct list_head *pentry, *dentry;
 	struct mtd_device *dev;
 	struct part_info *part, *prev_part;
 	char *p = buf;
 	char tmpbuf[32];
 	u32 size, offset, len, part_cnt;
 	u32 maxlen = buflen - 1;
 	DEBUGF("--- generate_mtdparts ---\n");
 	if (list_empty(&devices)) {
 		buf[0] = '\0';
 		return 0;
 	}
 	sprintf(p, "mtdparts=");
 	p += 9;
 	list_for_each(dentry, &devices) {
 		dev = list_entry(dentry, struct mtd_device, link);
 		/* copy mtd_id */
 		len = strlen(dev->id->mtd_id) + 1;
 		if (len > maxlen)
 			goto cleanup;
 		memcpy(p, dev->id->mtd_id, len - 1);
 		p += len - 1;
 		*(p++) = ':';
 		maxlen -= len;
 		/* format partitions */
 		prev_part = NULL;
 		part_cnt = 0;
 		list_for_each(pentry, &dev->parts) {
 			part = list_entry(pentry, struct part_info, link);
 			size = part->size;
 			offset = part->offset;
 			part_cnt++;
 			/* partition size */
 			memsize_format(tmpbuf, size);
 			len = strlen(tmpbuf);
 			if (len > maxlen)
 				goto cleanup;
 			memcpy(p, tmpbuf, len);
 			p += len;
 			maxlen -= len;
 			/* add offset only when there is a gap between
 			 * partitions */
 			if ((!prev_part && (offset != 0)) ||
 					(prev_part && ((prev_part->offset + prev_part->size) != part->offset))) {
 				memsize_format(tmpbuf, offset);
 				len = strlen(tmpbuf) + 1;
 				if (len > maxlen)
 					goto cleanup;
 				*(p++) = '@';
 				memcpy(p, tmpbuf, len - 1);
 				p += len - 1;
 				maxlen -= len;
 			}
 			/* copy name only if user supplied */
 			if(!part->auto_name) {
 				len = strlen(part->name) + 2;
 				if (len > maxlen)
 					goto cleanup;
 				*(p++) = '(';
 				memcpy(p, part->name, len - 2);
 				p += len - 2;
 				*(p++) = ')';
 				maxlen -= len;
 			}
 			/* ro mask flag */
 			if (part->mask_flags && MTD_WRITEABLE_CMD) {
 				len = 2;
 				if (len > maxlen)
 					goto cleanup;
 				*(p++) = 'r';
 				*(p++) = 'o';
 				maxlen -= 2;
 			}
 			/* print ',' separator if there are other partitions
 			 * following */
 			if (dev->num_parts > part_cnt) {
 				if (1 > maxlen)
 					goto cleanup;
 				*(p++) = ',';
 				maxlen--;
 			}
 			prev_part = part;
 		}
 		/* print ';' separator if there are other devices following */
 		if (dentry->next != &devices) {
 			if (1 > maxlen)
 				goto cleanup;
 			*(p++) = ';';
 			maxlen--;
 		}
 	}
 	/* we still have at least one char left, as we decremented maxlen at
 	 * the begining */
 	*p = '\0';
 	return 0;
 cleanup:
 	last_parts[0] = '\0';
 	return 1;
 }
 /**
  * Call generate_mtdparts to process all devices and generate corresponding
  * mtdparts string, save it in mtdparts environment variable.
  *
  * @param buf output buffer holding generated mtdparts string (output)
  * @param buflen buffer size
  * @return 0 on success, 1 otherwise
  */
 static int generate_mtdparts_save(char *buf, u32 buflen)
 {
 	int ret;
 	ret = generate_mtdparts(buf, buflen);
 	if ((buf[0] != '\0') && (ret == 0))
 		setenv("mtdparts", buf);
 	else
 		setenv("mtdparts", NULL);
 	return ret;
 }
 /**
  * Format and print out a partition list for each device from global device
  * list.
  */
 static void list_partitions(void)
 {
 	struct list_head *dentry, *pentry;
 	struct part_info *part;
 	struct mtd_device *dev;
 	int part_num;
 	DEBUGF("\n---list_partitions---\n");
 	list_for_each(dentry, &devices) {
 		dev = list_entry(dentry, struct mtd_device, link);
 		printf("\ndevice %s%d <%s>, # parts = %d\n",
 				MTD_DEV_TYPE(dev->id->type), dev->id->num,
 				dev->id->mtd_id, dev->num_parts);
 		printf(" #: name\t\t\tsize\t\toffset\t\tmask_flags\n");
 		/* list partitions for given device */
 		part_num = 0;
 		list_for_each(pentry, &dev->parts) {
 			part = list_entry(pentry, struct part_info, link);
 			printf("%2d: %-20s0x%08x\t0x%08x\t%d\n",
 					part_num, part->name, part->size,
 					part->offset, part->mask_flags);
 			part_num++;
 		}
 	}
 	if (list_empty(&devices))
 		printf("no partitions defined\n");
 	/* current_dev is not NULL only when we have non empty device list */
 	if (current_dev) {
 		part = jffs2_part_info(current_dev, current_partnum);
 		if (part) {
 			printf("\nactive partition: %s%d,%d - (%s) 0x%08lx @ 0x%08lx\n",
 					MTD_DEV_TYPE(current_dev->id->type),
 					current_dev->id->num, current_partnum,
 					part->name, part->size, part->offset);
 		} else {
 			printf("could not get current partition info\n\n");
 		}
 	}
 	printf("\ndefaults:\n");
 	printf("mtdids  : %s\n", mtdids_default);
 	printf("mtdparts: %s\n", mtdparts_default);
 }
 /**
  * Given partition identifier in form of <dev_type><dev_num>,<part_num> find
  * corresponding device and verify partition number.
  *
- * @param id string describing device and partition
+ * @param id string describing device and partition or partition name
  * @param dev pointer to the requested device (output)
  * @param part_num verified partition number (output)
  * @param part pointer to requested partition (output)
  * @return 0 on success, 1 otherwise
  */
 int find_dev_and_part(const char *id, struct mtd_device **dev,
 		u8 *part_num, struct part_info **part)
 {
+	struct list_head *dentry, *pentry;
 	u8 type, dnum, pnum;
 	const char *p;
 	DEBUGF("--- find_dev_and_part ---\nid = %s\n", id);
+	list_for_each(dentry, &devices) {
+		*part_num = 0;
+		*dev = list_entry(dentry, struct mtd_device, link);
+		list_for_each(pentry, &(*dev)->parts) {
+			*part = list_entry(pentry, struct part_info, link);
+			if (strcmp((*part)->name, id) == 0)
+				return 0;
+			(*part_num)++;
+		}
+	}
 	p = id;
 	*dev = NULL;
 	*part = NULL;
 	*part_num = 0;
 	if (id_parse(p, &p, &type, &dnum) != 0)
 		return 1;
 	if ((*p++ != ',') || (*p == '\0')) {
 		printf("no partition number specified\n");
 		return 1;
 	}
 	pnum = simple_strtoul(p, (char **)&p, 0);
 	if (*p != '\0') {
 		printf("unexpected trailing character '%c'\n", *p);
 		return 1;
 	}
 	if ((*dev = device_find(type, dnum)) == NULL) {
 		printf("no such device %s%d\n", MTD_DEV_TYPE(type), dnum);
 		return 1;
 	}
 	if ((*part = jffs2_part_info(*dev, pnum)) == NULL) {
 		printf("no such partition\n");
 		*dev = NULL;
 		return 1;
 	}
 	*part_num = pnum;
 	return 0;
 }
 /**
  * Find and delete partition. For partition id format see find_dev_and_part().
  *
  * @param id string describing device and partition
  * @return 0 on success, 1 otherwise
  */
 static int delete_partition(const char *id)
 {
 	u8 pnum;
 	struct mtd_device *dev;
 	struct part_info *part;
 	if (find_dev_and_part(id, &dev, &pnum, &part) == 0) {
 		DEBUGF("delete_partition: device = %s%d, partition %d = (%s) 0x%08lx@0x%08lx\n",
 				MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum,
 				part->name, part->size, part->offset);
 		if (part_del(dev, part) != 0)
 			return 1;
 		if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) {
 			printf("generated mtdparts too long, reseting to null\n");
 			return 1;
 		}
 		return 0;
 	}
 	printf("partition %s not found\n", id);
 	return 1;
 }
 /**
  * Accept character string describing mtd partitions and call device_parse()
  * for each entry. Add created devices to the global devices list.
  *
  * @param mtdparts string specifing mtd partitions
  * @return 0 on success, 1 otherwise
  */
 static int parse_mtdparts(const char *const mtdparts)
 {
 	const char *p = mtdparts;
 	struct mtd_device *dev;
 	int err = 1;
 	DEBUGF("\n---parse_mtdparts---\nmtdparts = %s\n\n", p);
 	/* delete all devices and partitions */
 	if (devices_init() != 0) {
 		printf("could not initialise device list\n");
 		return err;
 	}
 	/* re-read 'mtdparts' variable, devices_init may be updating env */
 	p = getenv("mtdparts");
 	if (strncmp(p, "mtdparts=", 9) != 0) {
 		printf("mtdparts variable doesn't start with 'mtdparts='\n");
 		return err;
 	}
 	p += 9;
 	while (p && (*p != '\0')) {
 		err = 1;
 		if ((device_parse(p, &p, &dev) != 0) || (!dev))
 			break;
 		DEBUGF("+ device: %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type),
 				dev->id->num, dev->id->mtd_id);
 		/* check if parsed device is already on the list */
 		if (device_find(dev->id->type, dev->id->num) != NULL) {
 			printf("device %s%d redefined, please correct mtdparts variable\n",
 					MTD_DEV_TYPE(dev->id->type), dev->id->num);
 			break;
 		}
 		list_add_tail(&dev->link, &devices);
 		err = 0;
 	}
 	if (err == 1) {
 		device_delall(&devices);
 		return 1;
 	}
 	return 0;
 }
 /**
  * Parse provided string describing mtdids mapping (see file header for mtdids
  * variable format). Allocate memory for each entry and add all found entries
  * to the global mtdids list.
  *
  * @param ids mapping string
  * @return 0 on success, 1 otherwise
  */
 static int parse_mtdids(const char *const ids)
 {
 	const char *p = ids;
 	const char *mtd_id;
 	int mtd_id_len;
 	struct mtdids *id;
 	struct list_head *entry, *n;
 	struct mtdids *id_tmp;
 	u8 type, num;
 	u32 size;
 	int ret = 1;
 	DEBUGF("\n---parse_mtdids---\nmtdids = %s\n\n", ids);
 	/* clean global mtdids list */
 	list_for_each_safe(entry, n, &mtdids) {
 		id_tmp = list_entry(entry, struct mtdids, link);
 		DEBUGF("mtdids del: %d %d\n", id_tmp->type, id_tmp->num);
 		list_del(entry);
 		free(id_tmp);
 	}
 	last_ids[0] = '\0';
 	INIT_LIST_HEAD(&mtdids);
 	while(p && (*p != '\0')) {
 		ret = 1;
 		/* parse 'nor'|'nand'<dev-num> */
 		if (id_parse(p, &p, &type, &num) != 0)
 			break;
 		if (*p != '=') {
 			printf("mtdids: incorrect <dev-num>\n");
 			break;
 		}
 		p++;
 		/* check if requested device exists */
 		if (device_validate(type, num, &size) != 0)
 			return 1;
 		/* locate <mtd-id> */
 		mtd_id = p;
 		if ((p = strchr(mtd_id, ',')) != NULL) {
 			mtd_id_len = p - mtd_id + 1;
 			p++;
 		} else {
 			mtd_id_len = strlen(mtd_id) + 1;
 		}
 		if (mtd_id_len == 0) {
 			printf("mtdids: no <mtd-id> identifier\n");
 			break;
 		}
 		/* check if this id is already on the list */
 		int double_entry = 0;
 		list_for_each(entry, &mtdids) {
 			id_tmp = list_entry(entry, struct mtdids, link);
 			if ((id_tmp->type == type) && (id_tmp->num == num)) {
 				double_entry = 1;
 				break;
 			}
 		}
 		if (double_entry) {
 			printf("device id %s%d redefined, please correct mtdids variable\n",
 					MTD_DEV_TYPE(type), num);
 			break;
 		}
 		/* allocate mtdids structure */
 		if (!(id = (struct mtdids *)malloc(sizeof(struct mtdids) + mtd_id_len))) {
 			printf("out of memory\n");
 			break;
 		}
 		memset(id, 0, sizeof(struct mtdids) + mtd_id_len);
 		id->num = num;
 		id->type = type;
 		id->size = size;
 		id->mtd_id = (char *)(id + 1);
 		strncpy(id->mtd_id, mtd_id, mtd_id_len - 1);
 		id->mtd_id[mtd_id_len - 1] = '\0';
 		INIT_LIST_HEAD(&id->link);
 		DEBUGF("+ id %s%d\t%16d bytes\t%s\n",
 				MTD_DEV_TYPE(id->type), id->num,
 				id->size, id->mtd_id);
 		list_add_tail(&id->link, &mtdids);
 		ret = 0;
 	}
 	if (ret == 1) {
 		/* clean mtdids list and free allocated memory */
 		list_for_each_safe(entry, n, &mtdids) {
 			id_tmp = list_entry(entry, struct mtdids, link);
 			list_del(entry);
 			free(id_tmp);
 		}
 		return 1;
 	}
 	return 0;
 }
 /**
  * Parse and initialize global mtdids mapping and create global
  * device/partition list.
  *
  * @return 0 on success, 1 otherwise
  */
 int mtdparts_init(void)
 {
 	static int initialized = 0;
 	const char *ids, *parts;
 	const char *current_partition;
 	int ids_changed;
 	char tmp_ep[PARTITION_MAXLEN];
 	DEBUGF("\n---mtdparts_init---\n");
 	if (!initialized) {
 		INIT_LIST_HEAD(&mtdids);
 		INIT_LIST_HEAD(&devices);
 		memset(last_ids, 0, MTDIDS_MAXLEN);
 		memset(last_parts, 0, MTDPARTS_MAXLEN);
 		memset(last_partition, 0, PARTITION_MAXLEN);
 		initialized = 1;
 	}
 	/* get variables */
 	ids = getenv("mtdids");
 	parts = getenv("mtdparts");
 	current_partition = getenv("partition");
 	/* save it for later parsing, cannot rely on current partition pointer
 	 * as 'partition' variable may be updated during init */
 	tmp_ep[0] = '\0';
 	if (current_partition)
 		strncpy(tmp_ep, current_partition, PARTITION_MAXLEN);
 	DEBUGF("last_ids  : %s\n", last_ids);
 	DEBUGF("env_ids   : %s\n", ids);
 	DEBUGF("last_parts: %s\n", last_parts);
 	DEBUGF("env_parts : %s\n\n", parts);
 	DEBUGF("last_partition : %s\n", last_partition);
 	DEBUGF("env_partition  : %s\n", current_partition);
 	/* if mtdids varible is empty try to use defaults */
 	if (!ids) {
 		if (mtdids_default) {
 			DEBUGF("mtdids variable not defined, using default\n");
 			ids = mtdids_default;
 			setenv("mtdids", (char *)ids);
 		} else {
 			printf("mtdids not defined, no default present\n");
 			return 1;
 		}
 	}
 	if (strlen(ids) > MTDIDS_MAXLEN - 1) {
 		printf("mtdids too long (> %d)\n", MTDIDS_MAXLEN);
 		return 1;
 	}
 	/* do no try to use defaults when mtdparts variable is not defined,
 	 * just check the length */
 	if (!parts)
 		printf("mtdparts variable not set, see 'help mtdparts'\n");
 	if (parts && (strlen(parts) > MTDPARTS_MAXLEN - 1)) {
 		printf("mtdparts too long (> %d)\n", MTDPARTS_MAXLEN);
 		return 1;
 	}
 	/* check if we have already parsed those mtdids */
 	if ((last_ids[0] != '\0') && (strcmp(last_ids, ids) == 0)) {
 		ids_changed = 0;
 	} else {
 		ids_changed = 1;
 		if (parse_mtdids(ids) != 0) {
 			devices_init();
 			return 1;
 		}
 		/* ok it's good, save new ids */
 		strncpy(last_ids, ids, MTDIDS_MAXLEN);
 	}
 	/* parse partitions if either mtdparts or mtdids were updated */
 	if (parts && ((last_parts[0] == '\0') || ((strcmp(last_parts, parts) != 0)) || ids_changed)) {
 		if (parse_mtdparts(parts) != 0)
 			return 1;
 		if (list_empty(&devices)) {
 			printf("mtdparts_init: no valid partitions\n");
 			return 1;
 		}
 		/* ok it's good, save new parts */
 		strncpy(last_parts, parts, MTDPARTS_MAXLEN);
 		/* reset first partition from first dev from the list as current */
 		current_dev = list_entry(devices.next, struct mtd_device, link);
 		current_partnum = 0;
 		current_save();
 		DEBUGF("mtdparts_init: current_dev  = %s%d, current_partnum = %d\n",
 				MTD_DEV_TYPE(current_dev->id->type),
 				current_dev->id->num, current_partnum);
 	}
 	/* mtdparts variable was reset to NULL, delete all devices/partitions */
 	if (!parts && (last_parts[0] != '\0'))
 		return devices_init();
 	/* do not process current partition if mtdparts variable is null */
 	if (!parts)
 		return 0;
 	/* is current partition set in environment? if so, use it */
 	if ((tmp_ep[0] != '\0') && (strcmp(tmp_ep, last_partition) != 0)) {
 		struct part_info *p;
 		struct mtd_device *cdev;
 		u8 pnum;
 		DEBUGF("--- getting current partition: %s\n", tmp_ep);
 		if (find_dev_and_part(tmp_ep, &cdev, &pnum, &p) == 0) {
 			current_dev = cdev;
 			current_partnum = pnum;
 			current_save();
 		}
 	} else if (getenv("partition") == NULL) {
 		DEBUGF("no partition variable set, setting...\n");
 		current_save();
 	}
 	return 0;
 }
 #else /* #ifdef CONFIG_JFFS2_CMDLINE */
 /*
  * 'Static' version of command line mtdparts_init() routine. Single partition on
  * a single device configuration.
  */
 /**
  * Parse and initialize global mtdids mapping and create global
  * device/partition list.
  *
  * @return 0 on success, 1 otherwise
  */
 int mtdparts_init(void)
 {
 	static int initialized = 0;
 	u32 size;
 	char *dev_name;
 	DEBUGF("\n---mtdparts_init---\n");
 	if (!initialized) {
 		struct mtdids *id;
 		struct part_info *part;
 		initialized = 1;
 		current_dev = (struct mtd_device *)
 			malloc(sizeof(struct mtd_device) +
 					sizeof(struct part_info) +
 					sizeof(struct mtdids));
 		if (!current_dev) {
 			printf("out of memory\n");
 			return 1;
 		}
 		memset(current_dev, 0, sizeof(struct mtd_device) +
 					sizeof(struct part_info) + sizeof(struct mtdids));
 		id = (struct mtdids *)(current_dev + 1);
 		part = (struct part_info *)(id + 1);
 		/* id */
 		id->mtd_id = "single part";
 #if defined(CONFIG_JFFS2_DEV)
 		dev_name = CONFIG_JFFS2_DEV;
 #else
 		dev_name = "nor0";
 #endif
 		if ((id_parse(dev_name, NULL, &id->type, &id->num) != 0) ||
 				(device_validate(id->type, id->num, &size) != 0)) {
 			printf("incorrect device: %s%d\n", MTD_DEV_TYPE(id->type), id->num);
 			free(current_dev);
 			return 1;
 		}
 		id->size = size;
 		INIT_LIST_HEAD(&id->link);
 		DEBUGF("dev id: type = %d, num = %d, size = 0x%08lx, mtd_id = %s\n",
 				id->type, id->num, id->size, id->mtd_id);
 		/* partition */
 		part->name = "static";
 		part->auto_name = 0;
 #if defined(CONFIG_JFFS2_PART_SIZE)
 		part->size = CONFIG_JFFS2_PART_SIZE;
 #else
 		part->size = SIZE_REMAINING;
 #endif
 #if defined(CONFIG_JFFS2_PART_OFFSET)
 		part->offset = CONFIG_JFFS2_PART_OFFSET;
 #else
 		part->offset = 0x00000000;
 #endif
 		part->dev = current_dev;
 		INIT_LIST_HEAD(&part->link);
 		/* recalculate size if needed */
 		if (part->size == SIZE_REMAINING)
 			part->size = id->size - part->offset;
 		DEBUGF("part  : name = %s, size = 0x%08lx, offset = 0x%08lx\n",
 				part->name, part->size, part->offset);
 		/* device */
 		current_dev->id = id;
 		INIT_LIST_HEAD(&current_dev->link);
 		current_dev->num_parts = 1;
 		INIT_LIST_HEAD(&current_dev->parts);
 		list_add(&part->link, &current_dev->parts);
 	}
 	return 0;
 }
 #endif /* #ifdef CONFIG_JFFS2_CMDLINE */
 /**
  * Return pointer to the partition of a requested number from a requested
  * device.
  *
  * @param dev device that is to be searched for a partition
  * @param part_num requested partition number
  * @return pointer to the part_info, NULL otherwise
  */
 static struct part_info* jffs2_part_info(struct mtd_device *dev, unsigned int part_num)
 {
 	struct list_head *entry;
 	struct part_info *part;
 	int num;
 	if (!dev)
 		return NULL;
 	DEBUGF("\n--- jffs2_part_info: partition number %d for device %s%d (%s)\n",
 			part_num, MTD_DEV_TYPE(dev->id->type),
 			dev->id->num, dev->id->mtd_id);
 	if (part_num >= dev->num_parts) {
 		printf("invalid partition number %d for device %s%d (%s)\n",
 				part_num, MTD_DEV_TYPE(dev->id->type),
 				dev->id->num, dev->id->mtd_id);
 		return NULL;
 	}
 	/* locate partition number, return it */
 	num = 0;
 	list_for_each(entry, &dev->parts) {
 		part = list_entry(entry, struct part_info, link);
 		if (part_num == num++) {
 			return part;
 		}
 	}
 	return NULL;
 }
 /***************************************************/
 /* U-boot commands				   */
 /***************************************************/
 /**
  * Routine implementing fsload u-boot command. This routine tries to load
  * a requested file from jffs2/cramfs filesystem on a current partition.
  *
  * @param cmdtp command internal data
  * @param flag command flag
  * @param argc number of arguments supplied to the command
  * @param argv arguments list
  * @return 0 on success, 1 otherwise
  */
 int do_jffs2_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
 	char *fsname;
 	char *filename;
 	int size;
 	struct part_info *part;
 	ulong offset = load_addr;
 	/* pre-set Boot file name */
 	if ((filename = getenv("bootfile")) == NULL) {
 		filename = "uImage";
 	}
 	if (argc == 2) {
 		filename = argv[1];
 	}
 	if (argc == 3) {
 		offset = simple_strtoul(argv[1], NULL, 16);
 		load_addr = offset;
 		filename = argv[2];
 	}
 	/* make sure we are in sync with env variables */
 	if (mtdparts_init() !=0)
 		return 1;
 	if ((part = jffs2_part_info(current_dev, current_partnum))){
 		/* check partition type for cramfs */
 		fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2");
 		printf("### %s loading '%s' to 0x%lx\n", fsname, filename, offset);
 		if (cramfs_check(part)) {
 			size = cramfs_load ((char *) offset, part, filename);
 		} else {
 			/* if this is not cramfs assume jffs2 */
 			size = jffs2_1pass_load((char *)offset, part, filename);
 		}
 		if (size > 0) {
 			char buf[10];
 			printf("### %s load complete: %d bytes loaded to 0x%lx\n",
 				fsname, size, offset);
 			sprintf(buf, "%x", size);
 			setenv("filesize", buf);
 		} else {
 			printf("### %s LOAD ERROR<%x> for %s!\n", fsname, size, filename);
 		}
 		return !(size > 0);
 	}
 	return 1;
 }
 /**
  * Routine implementing u-boot ls command which lists content of a given
  * directory on a current partition.
  *
  * @param cmdtp command internal data
  * @param flag command flag
  * @param argc number of arguments supplied to the command
  * @param argv arguments list
  * @return 0 on success, 1 otherwise
  */
 int do_jffs2_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
 	char *filename = "/";
 	int ret;
 	struct part_info *part;
 	if (argc == 2)
 		filename = argv[1];
 	/* make sure we are in sync with env variables */
 	if (mtdparts_init() !=0)
 		return 1;
 	if ((part = jffs2_part_info(current_dev, current_partnum))){
 		/* check partition type for cramfs */
 		if (cramfs_check(part)) {
 			ret = cramfs_ls (part, filename);
 		} else {
 			/* if this is not cramfs assume jffs2 */
 			ret = jffs2_1pass_ls(part, filename);
 		}
 		return ret ? 0 : 1;
 	}
 	return 1;
 }
 /**
  * Routine implementing u-boot fsinfo command. This routine prints out
  * miscellaneous filesystem informations/statistics.
  *
  * @param cmdtp command internal data
  * @param flag command flag
  * @param argc number of arguments supplied to the command
  * @param argv arguments list
  * @return 0 on success, 1 otherwise
  */
 int do_jffs2_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
 	struct part_info *part;
 	char *fsname;
 	int ret;
 	/* make sure we are in sync with env variables */
 	if (mtdparts_init() !=0)
 		return 1;
 	if ((part = jffs2_part_info(current_dev, current_partnum))){
 		/* check partition type for cramfs */
 		fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2");
 		printf("### filesystem type is %s\n", fsname);
 		if (cramfs_check(part)) {
 			ret = cramfs_info (part);
 		} else {
 			/* if this is not cramfs assume jffs2 */
 			ret = jffs2_1pass_info(part);
 		}
 		return ret ? 0 : 1;
 	}
 	return 1;
 }
 /* command line only */
 #ifdef CONFIG_JFFS2_CMDLINE
 /**
  * Routine implementing u-boot chpart command. Sets new current partition based
  * on the user supplied partition id. For partition id format see find_dev_and_part().
  *
  * @param cmdtp command internal data
  * @param flag command flag
  * @param argc number of arguments supplied to the command
  * @param argv arguments list
  * @return 0 on success, 1 otherwise
  */
 int do_jffs2_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
 /* command line only */
 	struct mtd_device *dev;
 	struct part_info *part;
 	u8 pnum;
 	if (mtdparts_init() !=0)
 		return 1;
 	if (argc < 2) {
 		printf("no partition id specified\n");
 		return 1;
 	}
 	if (find_dev_and_part(argv[1], &dev, &pnum, &part) != 0)
 		return 1;
 	current_dev = dev;
 	current_partnum = pnum;
 	current_save();
 	printf("partition changed to %s%d,%d\n",
 			MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum);
 	return 0;
 }
 /**
  * Routine implementing u-boot mtdparts command. Initialize/update default global
  * partition list and process user partition request (list, add, del).
  *
  * @param cmdtp command internal data
  * @param flag command flag
  * @param argc number of arguments supplied to the command
  * @param argv arguments list
  * @return 0 on success, 1 otherwise
  */
 int do_jffs2_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 {
 	if (argc == 2) {
 		if (strcmp(argv[1], "default") == 0) {
 			setenv("mtdids", (char *)mtdids_default);
 			setenv("mtdparts", (char *)mtdparts_default);
 			setenv("partition", NULL);
 			mtdparts_init();
 			return 0;
 		} else if (strcmp(argv[1], "delall") == 0) {
 			/* this may be the first run, initialize lists if needed */
 			mtdparts_init();
 			setenv("mtdparts", NULL);
 			/* devices_init() calls current_save() */
 			return devices_init();
 		}
 	}
 	/* make sure we are in sync with env variables */
 	if (mtdparts_init() != 0)
 		return 1;
 	if (argc == 1) {
 		list_partitions();
 		return 0;
 	}
 	/* mtdparts add <mtd-dev> <size>[@<offset>] <name> [ro] */
 	if (((argc == 5) || (argc == 6)) && (strcmp(argv[1], "add") == 0)) {
 #define PART_ADD_DESC_MAXLEN 64
 		char tmpbuf[PART_ADD_DESC_MAXLEN];
 		u8 type, num, len;
 		struct mtd_device *dev;
 		struct mtd_device *dev_tmp;
 		struct mtdids *id;
 		struct part_info *p;
 		if (id_parse(argv[2], NULL, &type, &num) != 0)
 			return 1;
 		if ((id = id_find(type, num)) == NULL) {
 			printf("no such device %s defined in mtdids variable\n", argv[2]);
 			return 1;
 		}
 		len = strlen(id->mtd_id) + 1;	/* 'mtd_id:' */
 		len += strlen(argv[3]);		/* size@offset */
 		len += strlen(argv[4]) + 2;	/* '(' name ')' */
 		if (argv[5] && (strlen(argv[5]) == 2))
 			len += 2;		/* 'ro' */
 		if (len >= PART_ADD_DESC_MAXLEN) {
 			printf("too long partition description\n");
 			return 1;
 		}
 		sprintf(tmpbuf, "%s:%s(%s)%s",
 				id->mtd_id, argv[3], argv[4], argv[5] ? argv[5] : "");
 		DEBUGF("add tmpbuf: %s\n", tmpbuf);
 		if ((device_parse(tmpbuf, NULL, &dev) != 0) || (!dev))
 			return 1;
 		DEBUGF("+ %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type),
 				dev->id->num, dev->id->mtd_id);
 		if ((dev_tmp = device_find(dev->id->type, dev->id->num)) == NULL) {
 			device_add(dev);
 		} else {
 			/* merge new partition with existing ones*/
 			p = list_entry(dev->parts.next, struct part_info, link);
 			if (part_add(dev_tmp, p) != 0) {
 				device_del(dev);
 				return 1;
 			}
 		}
 		if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) {
 			printf("generated mtdparts too long, reseting to null\n");
 			return 1;
 		}
 		return 0;
 	}
 	/* mtdparts del part-id */
 	if ((argc == 3) && (strcmp(argv[1], "del") == 0)) {
 		DEBUGF("del: part-id = %s\n", argv[2]);
 		return delete_partition(argv[2]);
 	}
 	printf ("Usage:\n%s\n", cmdtp->usage);
 	return 1;
 }
 #endif /* #ifdef CONFIG_JFFS2_CMDLINE */
 /***************************************************/
 U_BOOT_CMD(
 	fsload,	3,	0,	do_jffs2_fsload,
 	"fsload\t- load binary file from a filesystem image\n",
 	"[ off ] [ filename ]\n"
 	"    - load binary file from flash bank\n"
 	"      with offset 'off'\n"
 );
 U_BOOT_CMD(
 	ls,	2,	1,	do_jffs2_ls,
 	"ls\t- list files in a directory (default /)\n",
 	"[ directory ]\n"
 	"    - list files in a directory.\n"
 );
 U_BOOT_CMD(
 	fsinfo,	1,	1,	do_jffs2_fsinfo,
 	"fsinfo\t- print information about filesystems\n",
 	"    - print information about filesystems\n"
 );
 #ifdef CONFIG_JFFS2_CMDLINE
 U_BOOT_CMD(
 	chpart,	2,	0,	do_jffs2_chpart,
 	"chpart\t- change active partition\n",
 	"part-id\n"
 	"    - change active partition (e.g. part-id = nand0,1)\n"
 );
 U_BOOT_CMD(
 	mtdparts,	6,	0,	do_jffs2_mtdparts,
 	"mtdparts- define flash/nand partitions\n",
 	"\n"
 	"    - list partition table\n"
 	"mtdparts delall\n"
 	"    - delete all partitions\n"
 	"mtdparts del part-id\n"
 	"    - delete partition (e.g. part-id = nand0,1)\n"
 	"mtdparts add <mtd-dev> <size>[@<offset>] [<name>] [ro]\n"
 	"    - add partition\n"
 	"mtdparts default\n"
 	"    - reset partition table to defaults\n\n"
 	"-----\n\n"
 	"this command uses three environment variables:\n\n"
 	"'partition' - keeps current partition identifier\n\n"
 	"partition  := <part-id>\n"
 	"<part-id>  := <dev-id>,part_num\n\n"
 	"'mtdids' - linux kernel mtd device id <-> u-boot device id mapping\n\n"
 	"mtdids=<idmap>[,<idmap>,...]\n\n"
 	"<idmap>    := <dev-id>=<mtd-id>\n"
 	"<dev-id>   := 'nand'|'nor'<dev-num>\n"
 	"<dev-num>  := mtd device number, 0...\n"
 	"<mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)\n\n"
 	"'mtdparts' - partition list\n\n"
 	"mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]\n\n"
 	"<mtd-def>  := <mtd-id>:<part-def>[,<part-def>...]\n"
 	"<mtd-id>   := unique device tag used by linux kernel to find mtd device (mtd->name)\n"
 	"<part-def> := <size>[@<offset>][<name>][<ro-flag>]\n"
 	"<size>     := standard linux memsize OR '-' to denote all remaining space\n"
 	"<offset>   := partition start offset within the device\n"
 	"<name>     := '(' NAME ')'\n"
 	"<ro-flag>  := when set to 'ro' makes partition read-only (not used, passed to kernel)\n"
 );
 #endif /* #ifdef CONFIG_JFFS2_CMDLINE */
 /***************************************************/
 #endif /* CFG_CMD_JFFS2 */

common/cmd_nand.c

Diff comments View file @ d983189

1	/*	1	/*
2	* Driver for NAND support, Rick Bronson	2	* Driver for NAND support, Rick Bronson
3	* borrowed heavily from:	3	* borrowed heavily from:
4	* (c) 1999 Machine Vision Holdings, Inc.	4	* (c) 1999 Machine Vision Holdings, Inc.
5	* (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>	5	* (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
6	*	6	*
7	* Added 16-bit nand support	7	* Added 16-bit nand support
8	* (C) 2004 Texas Instruments	8	* (C) 2004 Texas Instruments
9	*/	9	*/
10		10
11	#include <common.h>	11	#include <common.h>
12		12
13		13
14	#ifndef CFG_NAND_LEGACY	14	#ifndef CFG_NAND_LEGACY
15	/*	15	/*
16	*	16	*
17	* New NAND support	17	* New NAND support
18	*	18	*
19	*/	19	*/
20	#include <common.h>	20	#include <common.h>
21		21
22	#if (CONFIG_COMMANDS & CFG_CMD_NAND)	22	#if (CONFIG_COMMANDS & CFG_CMD_NAND)
23		23
24	#include <command.h>	24	#include <command.h>
25	#include <watchdog.h>	25	#include <watchdog.h>
26	#include <malloc.h>	26	#include <malloc.h>
27	#include <asm/byteorder.h>	27	#include <asm/byteorder.h>
28		28
29	#ifdef CONFIG_SHOW_BOOT_PROGRESS	29	#ifdef CONFIG_SHOW_BOOT_PROGRESS
30	# include <status_led.h>	30	# include <status_led.h>
31	# define SHOW_BOOT_PROGRESS(arg) show_boot_progress(arg)	31	# define SHOW_BOOT_PROGRESS(arg) show_boot_progress(arg)
32	#else	32	#else
33	# define SHOW_BOOT_PROGRESS(arg)	33	# define SHOW_BOOT_PROGRESS(arg)
34	#endif	34	#endif
35		35
36	#include <jffs2/jffs2.h>	36	#include <jffs2/jffs2.h>
37	#include <nand.h>	37	#include <nand.h>
38		38
		39	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
		40
		41	/* parition handling routines */
		42	int mtdparts_init(void);
		43	int id_parse(const char id, const char ret_id, u8 dev_type, u8 *dev_num);
		44	int find_dev_and_part(const char id, struct mtd_device *dev,
		45	u8 part_num, struct part_info *part);
		46	#endif
		47
39	extern nand_info_t nand_info[]; /* info for NAND chips */	48	extern nand_info_t nand_info[]; /* info for NAND chips */
40		49
41	static int nand_dump_oob(nand_info_t *nand, ulong off)	50	static int nand_dump_oob(nand_info_t *nand, ulong off)
42	{	51	{
43	return 0;	52	return 0;
44	}	53	}
45		54
46	static int nand_dump(nand_info_t *nand, ulong off)	55	static int nand_dump(nand_info_t *nand, ulong off)
47	{	56	{
48	int i;	57	int i;
49	u_char buf, p;	58	u_char buf, p;
50		59
51	buf = malloc(nand->oobblock + nand->oobsize);	60	buf = malloc(nand->oobblock + nand->oobsize);
52	if (!buf) {	61	if (!buf) {
53	puts("No memory for page buffer\n");	62	puts("No memory for page buffer\n");
54	return 1;	63	return 1;
55	}	64	}
56	off &= ~(nand->oobblock - 1);	65	off &= ~(nand->oobblock - 1);
57	i = nand_read_raw(nand, buf, off, nand->oobblock, nand->oobsize);	66	i = nand_read_raw(nand, buf, off, nand->oobblock, nand->oobsize);
58	if (i < 0) {	67	if (i < 0) {
59	printf("Error (%d) reading page %08x\n", i, off);	68	printf("Error (%d) reading page %08x\n", i, off);
60	free(buf);	69	free(buf);
61	return 1;	70	return 1;
62	}	71	}
63	printf("Page %08x dump:\n", off);	72	printf("Page %08x dump:\n", off);
64	i = nand->oobblock >> 4; p = buf;	73	i = nand->oobblock >> 4; p = buf;
65	while (i--) {	74	while (i--) {
66	printf( "\t%02x %02x %02x %02x %02x %02x %02x %02x"	75	printf( "\t%02x %02x %02x %02x %02x %02x %02x %02x"
67	" %02x %02x %02x %02x %02x %02x %02x %02x\n",	76	" %02x %02x %02x %02x %02x %02x %02x %02x\n",
68	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],	77	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
69	p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);	78	p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
70	p += 16;	79	p += 16;
71	}	80	}
72	puts("OOB:\n");	81	puts("OOB:\n");
73	i = nand->oobsize >> 3;	82	i = nand->oobsize >> 3;
74	while (i--) {	83	while (i--) {
75	printf( "\t%02x %02x %02x %02x %02x %02x %02x %02x\n",	84	printf( "\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
76	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);	85	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
77	p += 8;	86	p += 8;
78	}	87	}
79	free(buf);	88	free(buf);
80		89
81	return 0;	90	return 0;
82	}	91	}
83		92
84	/* ------------------------------------------------------------------------- */	93	/* ------------------------------------------------------------------------- */
85		94
86	static void	95	static inline int str2long(char p, ulong num)
87	arg_off_size(int argc, char argv[], ulong off, ulong *size, ulong totsize)
88	{	96	{
89	*off = 0;	97	char *endptr;
90	*size = 0;
91		98
92	#if defined(CONFIG_JFFS2_NAND) && defined(CFG_JFFS_CUSTOM_PART)	99	*num = simple_strtoul(p, &endptr, 16);
93	if (argc >= 1 && strcmp(argv[0], "partition") == 0) {	100	return (p != '\0' && endptr == '\0') ? 1 : 0;
94	int part_num;	101	}
95	struct part_info *part;
96	const char *partstr;
97		102
98	if (argc >= 2)	103	static int
99	partstr = argv[1];	104	arg_off_size(int argc, char argv[], nand_info_t nand, ulong off, ulong size)
100	else	105	{
101	partstr = getenv("partition");	106	int idx = nand_curr_device;
		107	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
		108	struct mtd_device *dev;
		109	struct part_info *part;
		110	u8 pnum;
102		111
103	if (partstr)	112	if (argc >= 1 && !(str2long(argv[0], off))) {
104	part_num = (int)simple_strtoul(partstr, NULL, 10);	113	if ((mtdparts_init() == 0) &&
105	else	114	(find_dev_and_part(argv[0], &dev, &pnum, &part) == 0)) {
106	part_num = 0;	115	if (dev->id->type != MTD_DEV_TYPE_NAND) {
107		116	puts("not a NAND device\n");
108	part = jffs2_part_info(part_num);	117	return -1;
109	if (part == NULL) {	118	}
110	printf("\nInvalid partition %d\n", part_num);	119	*off = part->offset;
111	return;	120	if (argc >= 2) {
		121	if (!(str2long(argv[1], size))) {
		122	printf("'%s' is not a number\n", argv[1]);
		123	return -1;
		124	}
		125	if (*size > part->size)
		126	*size = part->size;
		127	} else {
		128	*size = part->size;
		129	}
		130	idx = dev->id->num;
		131	*nand = nand_info[idx];
		132	goto out;
112	}	133	}
113	*size = part->size;	134	}
114	*off = (ulong)part->offset;
115	} else
116	#endif	135	#endif
117	{
118	if (argc >= 1)
119	*off = (ulong)simple_strtoul(argv[0], NULL, 16);
120	else
121	*off = 0;
122		136
123	if (argc >= 2)	137	if (argc >= 1) {
124	*size = (ulong)simple_strtoul(argv[1], NULL, 16);	138	if (!(str2long(argv[0], off))) {
125	else	139	printf("'%s' is not a number\n", argv[0]);
126	size = totsize - off;	140	return -1;
		141	}
		142	} else {
		143	*off = 0;
		144	}
127		145
		146	if (argc >= 2) {
		147	if (!(str2long(argv[1], size))) {
		148	printf("'%s' is not a number\n", argv[1]);
		149	return -1;
		150	}
		151	} else {
		152	size = nand->size - off;
128	}	153	}
129		154
		155	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
		156	out:
		157	#endif
		158	printf("device %d ", idx);
		159	if (*size == nand->size)
		160	puts("whole chip\n");
		161	else
		162	printf("offset 0x%x, size 0x%x\n", off, size);
		163	return 0;
130	}	164	}
131		165
132	int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])	166	int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
133	{	167	{
134	int i, dev, ret;	168	int i, dev, ret;
135	ulong addr, off, size;	169	ulong addr, off, size;
136	char cmd, s;	170	char cmd, s;
137	nand_info_t *nand;	171	nand_info_t *nand;
138	int quiet = 0;	172	int quiet = 0;
139	const char *quiet_str = getenv("quiet");	173	const char *quiet_str = getenv("quiet");
140		174
141	/* at least two arguments please */	175	/* at least two arguments please */
142	if (argc < 2)	176	if (argc < 2)
143	goto usage;	177	goto usage;
144		178
145	if (quiet_str)	179	if (quiet_str)
146	quiet = simple_strtoul(quiet_str, NULL, 0) != 0;	180	quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
147		181
148	cmd = argv[1];	182	cmd = argv[1];
149		183
150	if (strcmp(cmd, "info") == 0) {	184	if (strcmp(cmd, "info") == 0) {
151		185
152	putc('\n');	186	putc('\n');
153	for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {	187	for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {
154	if (nand_info[i].name)	188	if (nand_info[i].name)
155	printf("Device %d: %s, sector size %lu KiB\n",	189	printf("Device %d: %s, sector size %lu KiB\n",
156	i, nand_info[i].name,	190	i, nand_info[i].name,
157	nand_info[i].erasesize >> 10);	191	nand_info[i].erasesize >> 10);
158	}	192	}
159	return 0;	193	return 0;
160	}	194	}
161		195
162	if (strcmp(cmd, "device") == 0) {	196	if (strcmp(cmd, "device") == 0) {
163		197
164	if (argc < 3) {	198	if (argc < 3) {
165	if ((nand_curr_device < 0) \|\|	199	if ((nand_curr_device < 0) \|\|
166	(nand_curr_device >= CFG_MAX_NAND_DEVICE))	200	(nand_curr_device >= CFG_MAX_NAND_DEVICE))
167	puts("\nno devices available\n");	201	puts("\nno devices available\n");
168	else	202	else
169	printf("\nDevice %d: %s\n", nand_curr_device,	203	printf("\nDevice %d: %s\n", nand_curr_device,
170	nand_info[nand_curr_device].name);	204	nand_info[nand_curr_device].name);
171	return 0;	205	return 0;
172	}	206	}
173	dev = (int)simple_strtoul(argv[2], NULL, 10);	207	dev = (int)simple_strtoul(argv[2], NULL, 10);
174	if (dev < 0 \|\| dev >= CFG_MAX_NAND_DEVICE \|\| !nand_info[dev].name) {	208	if (dev < 0 \|\| dev >= CFG_MAX_NAND_DEVICE \|\| !nand_info[dev].name) {
175	puts("No such device\n");	209	puts("No such device\n");
176	return 1;	210	return 1;
177	}	211	}
178	printf("Device %d: %s", dev, nand_info[dev].name);	212	printf("Device %d: %s", dev, nand_info[dev].name);
179	puts("... is now current device\n");	213	puts("... is now current device\n");
180	nand_curr_device = dev;	214	nand_curr_device = dev;
181		215
182	#ifdef CFG_NAND_SELECT_DEVICE	216	#ifdef CFG_NAND_SELECT_DEVICE
183	/*	217	/*
184	* Select the chip in the board/cpu specific driver	218	* Select the chip in the board/cpu specific driver
185	*/	219	*/
186	board_nand_select_device(nand_info[dev].priv, dev);	220	board_nand_select_device(nand_info[dev].priv, dev);
187	#endif	221	#endif
188		222
189	return 0;	223	return 0;
190	}	224	}
191		225
192	if (strcmp(cmd, "bad") != 0 && strcmp(cmd, "erase") != 0 &&	226	if (strcmp(cmd, "bad") != 0 && strcmp(cmd, "erase") != 0 &&
193	strncmp(cmd, "dump", 4) != 0 &&	227	strncmp(cmd, "dump", 4) != 0 &&
194	strncmp(cmd, "read", 4) != 0 && strncmp(cmd, "write", 5) != 0 &&	228	strncmp(cmd, "read", 4) != 0 && strncmp(cmd, "write", 5) != 0 &&
195	strcmp(cmd, "scrub") != 0 && strcmp(cmd, "markbad") != 0 &&	229	strcmp(cmd, "scrub") != 0 && strcmp(cmd, "markbad") != 0 &&
196	strcmp(cmd, "biterr") != 0 &&	230	strcmp(cmd, "biterr") != 0 &&
197	strcmp(cmd, "lock") != 0 && strcmp(cmd, "unlock") != 0 )	231	strcmp(cmd, "lock") != 0 && strcmp(cmd, "unlock") != 0 )
198	goto usage;	232	goto usage;
199		233
200	/* the following commands operate on the current device */	234	/* the following commands operate on the current device */
201	if (nand_curr_device < 0 \|\| nand_curr_device >= CFG_MAX_NAND_DEVICE \|\|	235	if (nand_curr_device < 0 \|\| nand_curr_device >= CFG_MAX_NAND_DEVICE \|\|
202	!nand_info[nand_curr_device].name) {	236	!nand_info[nand_curr_device].name) {
203	puts("\nno devices available\n");	237	puts("\nno devices available\n");
204	return 1;	238	return 1;
205	}	239	}
206	nand = &nand_info[nand_curr_device];	240	nand = &nand_info[nand_curr_device];
207		241
208	if (strcmp(cmd, "bad") == 0) {	242	if (strcmp(cmd, "bad") == 0) {
209	printf("\nDevice %d bad blocks:\n", nand_curr_device);	243	printf("\nDevice %d bad blocks:\n", nand_curr_device);
210	for (off = 0; off < nand->size; off += nand->erasesize)	244	for (off = 0; off < nand->size; off += nand->erasesize)
211	if (nand_block_isbad(nand, off))	245	if (nand_block_isbad(nand, off))
212	printf(" %08x\n", off);	246	printf(" %08x\n", off);
213	return 0;	247	return 0;
214	}	248	}
215		249
		250	/*
		251	* Syntax is:
		252	* 0 1 2 3 4
		253	* nand erase [clean] [off size]
		254	*/
216	if (strcmp(cmd, "erase") == 0 \|\| strcmp(cmd, "scrub") == 0) {	255	if (strcmp(cmd, "erase") == 0 \|\| strcmp(cmd, "scrub") == 0) {
217	nand_erase_options_t opts;	256	nand_erase_options_t opts;
218	int clean = argc >= 3 && !strcmp("clean", argv[2]);	257	/* "clean" at index 2 means request to write cleanmarker */
219	int rest_argc = argc - 2;	258	int clean = argc > 2 && !strcmp("clean", argv[2]);
220	char **rest_argv = argv + 2;	259	int o = clean ? 3 : 2;
221	int scrub = !strcmp(cmd, "scrub");	260	int scrub = !strcmp(cmd, "scrub");
222		261
223	if (clean) {	262	printf("\nNAND %s: ", scrub ? "scrub" : "erase");
224	rest_argc--;	263	/* skip first two or three arguments, look for offset and size */
225	rest_argv++;	264	if (arg_off_size(argc - o, argv + o, nand, &off, &size) != 0)
226	}	265	return 1;
227		266
228	if (rest_argc == 0) {
229
230	printf("\nNAND %s: device %d whole chip\n",
231	cmd,
232	nand_curr_device);
233
234	off = size = 0;
235	} else {
236	arg_off_size(rest_argc, rest_argv, &off, &size,
237	nand->size);
238
239	if (off == 0 && size == 0)
240	return 1;
241
242	printf("\nNAND %s: device %d offset 0x%x, size 0x%x\n",
243	cmd, nand_curr_device, off, size);
244	}
245
246	memset(&opts, 0, sizeof(opts));	267	memset(&opts, 0, sizeof(opts));
247	opts.offset = off;	268	opts.offset = off;
248	opts.length = size;	269	opts.length = size;
249	opts.jffs2 = clean;	270	opts.jffs2 = clean;
250	opts.quiet = quiet;	271	opts.quiet = quiet;
251		272
252	if (scrub) {	273	if (scrub) {
253	printf("Warning: "	274	puts("Warning: "
254	"scrub option will erase all factory set "	275	"scrub option will erase all factory set "
255	"bad blocks!\n"	276	"bad blocks!\n"
256	" "	277	" "
257	"There is no reliable way to recover them.\n"	278	"There is no reliable way to recover them.\n"
258	" "	279	" "
259	"Use this command only for testing purposes "	280	"Use this command only for testing purposes "
260	"if you\n"	281	"if you\n"
261	" "	282	" "
262	"are sure of what you are doing!\n"	283	"are sure of what you are doing!\n"
263	"\nReally scrub this NAND flash? <y/N>\n"	284	"\nReally scrub this NAND flash? <y/N>\n");
264	);
265		285
266	if (getc() == 'y' && getc() == '\r') {	286	if (getc() == 'y' && getc() == '\r') {
267	opts.scrub = 1;	287	opts.scrub = 1;
268	} else {	288	} else {
269	printf("scrub aborted\n");	289	puts("scrub aborted\n");
270	return -1;	290	return -1;
271	}	291	}
272	}	292	}
273	ret = nand_erase_opts(nand, &opts);	293	ret = nand_erase_opts(nand, &opts);
274	printf("%s\n", ret ? "ERROR" : "OK");	294	printf("%s\n", ret ? "ERROR" : "OK");
275		295
276	return ret == 0 ? 0 : 1;	296	return ret == 0 ? 0 : 1;
277	}	297	}
278		298
279	if (strncmp(cmd, "dump", 4) == 0) {	299	if (strncmp(cmd, "dump", 4) == 0) {
280	if (argc < 3)	300	if (argc < 3)
281	goto usage;	301	goto usage;
282		302
283	s = strchr(cmd, '.');	303	s = strchr(cmd, '.');
284	off = (int)simple_strtoul(argv[2], NULL, 16);	304	off = (int)simple_strtoul(argv[2], NULL, 16);
285		305
286	if (s != NULL && strcmp(s, ".oob") == 0)	306	if (s != NULL && strcmp(s, ".oob") == 0)
287	ret = nand_dump_oob(nand, off);	307	ret = nand_dump_oob(nand, off);
288	else	308	else
289	ret = nand_dump(nand, off);	309	ret = nand_dump(nand, off);
290		310
291	return ret == 0 ? 1 : 0;	311	return ret == 0 ? 1 : 0;
292		312
293	}	313	}
294		314
295	/* read write */	315	/* read write */
296	if (strncmp(cmd, "read", 4) == 0 \|\| strncmp(cmd, "write", 5) == 0) {	316	if (strncmp(cmd, "read", 4) == 0 \|\| strncmp(cmd, "write", 5) == 0) {
297	int read;	317	int read;
298		318
299	if (argc < 4)	319	if (argc < 4)
300	goto usage;	320	goto usage;
301		321
302	addr = (ulong)simple_strtoul(argv[2], NULL, 16);	322	addr = (ulong)simple_strtoul(argv[2], NULL, 16);
303		323
304	arg_off_size(argc - 3, argv + 3, &off, &size, nand->size);	324	read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
305	if (off == 0 && size == 0)	325	printf("\nNAND %s: ", read ? "read" : "write");
		326	if (arg_off_size(argc - 3, argv + 3, nand, &off, &size) != 0)
306	return 1;	327	return 1;
307		328
308	read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
309	printf("\nNAND %s: device %d offset %u, size %u ... ",
310	read ? "read" : "write", nand_curr_device, off, size);
311
312	s = strchr(cmd, '.');	329	s = strchr(cmd, '.');
313	if (s != NULL &&	330	if (s != NULL &&
314	(!strcmp(s, ".jffs2") \|\| !strcmp(s, ".e") \|\| !strcmp(s, ".i"))) {	331	(!strcmp(s, ".jffs2") \|\| !strcmp(s, ".e") \|\| !strcmp(s, ".i"))) {
315	if (read) {	332	if (read) {
316	/* read */	333	/* read */
317	nand_read_options_t opts;	334	nand_read_options_t opts;
318	memset(&opts, 0, sizeof(opts));	335	memset(&opts, 0, sizeof(opts));
319	opts.buffer = (u_char*) addr;	336	opts.buffer = (u_char*) addr;
320	opts.length = size;	337	opts.length = size;
321	opts.offset = off;	338	opts.offset = off;
322	opts.quiet = quiet;	339	opts.quiet = quiet;
323	ret = nand_read_opts(nand, &opts);	340	ret = nand_read_opts(nand, &opts);
324	} else {	341	} else {
325	/* write */	342	/* write */
326	nand_write_options_t opts;	343	nand_write_options_t opts;
327	memset(&opts, 0, sizeof(opts));	344	memset(&opts, 0, sizeof(opts));
328	opts.buffer = (u_char*) addr;	345	opts.buffer = (u_char*) addr;
329	opts.length = size;	346	opts.length = size;
330	opts.offset = off;	347	opts.offset = off;
331	/* opts.forcejffs2 = 1; */	348	/* opts.forcejffs2 = 1; */
332	opts.pad = 1;	349	opts.pad = 1;
333	opts.blockalign = 1;	350	opts.blockalign = 1;
334	opts.quiet = quiet;	351	opts.quiet = quiet;
335	ret = nand_write_opts(nand, &opts);	352	ret = nand_write_opts(nand, &opts);
336	}	353	}
337	printf("%s\n", ret ? "ERROR" : "OK");	354	} else {
338	return ret == 0 ? 0 : 1;	355	if (read)
		356	ret = nand_read(nand, off, &size, (u_char *)addr);
		357	else
		358	ret = nand_write(nand, off, &size, (u_char *)addr);
339	}	359	}
340		360
341	if (read)
342	ret = nand_read(nand, off, &size, (u_char *)addr);
343	else
344	ret = nand_write(nand, off, &size, (u_char *)addr);
345
346	printf(" %d bytes %s: %s\n", size,	361	printf(" %d bytes %s: %s\n", size,
347	read ? "read" : "written", ret ? "ERROR" : "OK");	362	read ? "read" : "written", ret ? "ERROR" : "OK");
348		363
349	return ret == 0 ? 0 : 1;	364	return ret == 0 ? 0 : 1;
350	}	365	}
351		366
352	if (strcmp(cmd, "markbad") == 0) {	367	if (strcmp(cmd, "markbad") == 0) {
353	addr = (ulong)simple_strtoul(argv[2], NULL, 16);	368	addr = (ulong)simple_strtoul(argv[2], NULL, 16);
354		369
355	int ret = nand->block_markbad(nand, addr);	370	int ret = nand->block_markbad(nand, addr);
356	if (ret == 0) {	371	if (ret == 0) {
357	printf("block 0x%08lx successfully marked as bad\n",	372	printf("block 0x%08lx successfully marked as bad\n",
358	(ulong) addr);	373	(ulong) addr);
359	return 0;	374	return 0;
360	} else {	375	} else {
361	printf("block 0x%08lx NOT marked as bad! ERROR %d\n",	376	printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
362	(ulong) addr, ret);	377	(ulong) addr, ret);
363	}	378	}
364	return 1;	379	return 1;
365	}	380	}
366	if (strcmp(cmd, "biterr") == 0) {	381	if (strcmp(cmd, "biterr") == 0) {
367	/* todo */	382	/* todo */
368	return 1;	383	return 1;
369	}	384	}
370		385
371	if (strcmp(cmd, "lock") == 0) {	386	if (strcmp(cmd, "lock") == 0) {
372	int tight = 0;	387	int tight = 0;
373	int status = 0;	388	int status = 0;
374	if (argc == 3) {	389	if (argc == 3) {
375	if (!strcmp("tight", argv[2]))	390	if (!strcmp("tight", argv[2]))
376	tight = 1;	391	tight = 1;
377	if (!strcmp("status", argv[2]))	392	if (!strcmp("status", argv[2]))
378	status = 1;	393	status = 1;
379	}	394	}
380		395
381	if (status) {	396	if (status) {
382	ulong block_start = 0;	397	ulong block_start = 0;
383	ulong off;	398	ulong off;
384	int last_status = -1;	399	int last_status = -1;
385		400
386	struct nand_chip *nand_chip = nand->priv;	401	struct nand_chip *nand_chip = nand->priv;
387	/* check the WP bit */	402	/* check the WP bit */
388	nand_chip->cmdfunc (nand, NAND_CMD_STATUS, -1, -1);	403	nand_chip->cmdfunc (nand, NAND_CMD_STATUS, -1, -1);
389	printf("device is %swrite protected\n",	404	printf("device is %swrite protected\n",
390	(nand_chip->read_byte(nand) & 0x80 ?	405	(nand_chip->read_byte(nand) & 0x80 ?
391	"NOT " : "" ) );	406	"NOT " : "" ) );
392		407
393	for (off = 0; off < nand->size; off += nand->oobblock) {	408	for (off = 0; off < nand->size; off += nand->oobblock) {
394	int s = nand_get_lock_status(nand, off);	409	int s = nand_get_lock_status(nand, off);
395		410
396	/* print message only if status has changed	411	/* print message only if status has changed
397	* or at end of chip	412	* or at end of chip
398	*/	413	*/
399	if (off == nand->size - nand->oobblock	414	if (off == nand->size - nand->oobblock
400	\|\| (s != last_status && off != 0)) {	415	\|\| (s != last_status && off != 0)) {
401		416
402	printf("%08x - %08x: %8d pages %s%s%s\n",	417	printf("%08x - %08x: %8d pages %s%s%s\n",
403	block_start,	418	block_start,
404	off-1,	419	off-1,
405	(off-block_start)/nand->oobblock,	420	(off-block_start)/nand->oobblock,
406	((last_status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),	421	((last_status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
407	((last_status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),	422	((last_status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
408	((last_status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));	423	((last_status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
409	}	424	}
410		425
411	last_status = s;	426	last_status = s;
412	}	427	}
413	} else {	428	} else {
414	if (!nand_lock(nand, tight)) {	429	if (!nand_lock(nand, tight)) {
415	printf ("NAND flash successfully locked\n");	430	puts("NAND flash successfully locked\n");
416	} else {	431	} else {
417	printf ("Error locking NAND flash. \n");	432	puts("Error locking NAND flash\n");
418	return 1;	433	return 1;
419	}	434	}
420	}	435	}
421	return 0;	436	return 0;
422	}	437	}
423		438
424	if (strcmp(cmd, "unlock") == 0) {	439	if (strcmp(cmd, "unlock") == 0) {
425	if (argc == 2) {	440	if (arg_off_size(argc - 2, argv + 2, nand, &off, &size) < 0)
426	off = 0;	441	return 1;
427	size = nand->size;
428	} else {
429	arg_off_size(argc - 2, argv + 2, &off, &size,
430	nand->size);
431	}
432		442
433	if (!nand_unlock(nand, off, size)) {	443	if (!nand_unlock(nand, off, size)) {
434	printf("NAND flash successfully unlocked\n");	444	puts("NAND flash successfully unlocked\n");
435	} else {	445	} else {
436	printf("Error unlocking NAND flash. "	446	puts("Error unlocking NAND flash, "
437	"Write and erase will probably fail\n");	447	"write and erase will probably fail\n");
438	return 1;	448	return 1;
439	}	449	}
440	return 0;	450	return 0;
441	}	451	}
442		452
443	usage:	453	usage:
444	printf("Usage:\n%s\n", cmdtp->usage);	454	printf("Usage:\n%s\n", cmdtp->usage);
445	return 1;	455	return 1;
446	}	456	}
447		457
448	U_BOOT_CMD(nand, 5, 1, do_nand,	458	U_BOOT_CMD(nand, 5, 1, do_nand,
449	"nand - NAND sub-system\n",	459	"nand - NAND sub-system\n",
450	"info - show available NAND devices\n"	460	"info - show available NAND devices\n"
451	"nand device [dev] - show or set current device\n"	461	"nand device [dev] - show or set current device\n"
452	"nand read[.jffs2] - addr off size\n"	462	"nand read[.jffs2] - addr off\|partition size\n"
453	"nand write[.jffs2] - addr off size - read/write `size' bytes starting\n"	463	"nand write[.jffs2] - addr off\|partiton size - read/write `size' bytes starting\n"
454	" at offset `off' to/from memory address `addr'\n"	464	" at offset `off' to/from memory address `addr'\n"
455	"nand erase [clean] [off size] - erase `size' bytes from\n"	465	"nand erase [clean] [off size] - erase `size' bytes from\n"
456	" offset `off' (entire device if not specified)\n"	466	" offset `off' (entire device if not specified)\n"
457	"nand bad - show bad blocks\n"	467	"nand bad - show bad blocks\n"
458	"nand dump[.oob] off - dump page\n"	468	"nand dump[.oob] off - dump page\n"
459	"nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"	469	"nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
460	"nand markbad off - mark bad block at offset (UNSAFE)\n"	470	"nand markbad off - mark bad block at offset (UNSAFE)\n"
461	"nand biterr off - make a bit error at offset (UNSAFE)\n"	471	"nand biterr off - make a bit error at offset (UNSAFE)\n"
462	"nand lock [tight] [status] - bring nand to lock state or display locked pages\n"	472	"nand lock [tight] [status] - bring nand to lock state or display locked pages\n"
463	"nand unlock [offset] [size] - unlock section\n");	473	"nand unlock [offset] [size] - unlock section\n");
464		474
465	int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])	475	static int nand_load_image(cmd_tbl_t cmdtp, nand_info_t nand,
		476	ulong offset, ulong addr, char *cmd)
466	{	477	{
467	char *boot_device = NULL;
468	char *ep;
469	int dev;
470	int r;	478	int r;
471	ulong addr, cnt, offset = 0;	479	char *ep;
		480	ulong cnt;
472	image_header_t *hdr;	481	image_header_t *hdr;
473	nand_info_t *nand;
474		482
475	switch (argc) {	483	printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
476	case 1:
477	addr = CFG_LOAD_ADDR;
478	boot_device = getenv("bootdevice");
479	break;
480	case 2:
481	addr = simple_strtoul(argv[1], NULL, 16);
482	boot_device = getenv("bootdevice");
483	break;
484	case 3:
485	addr = simple_strtoul(argv[1], NULL, 16);
486	boot_device = argv[2];
487	break;
488	case 4:
489	addr = simple_strtoul(argv[1], NULL, 16);
490	boot_device = argv[2];
491	offset = simple_strtoul(argv[3], NULL, 16);
492	break;
493	default:
494	printf("Usage:\n%s\n", cmdtp->usage);
495	SHOW_BOOT_PROGRESS(-1);
496	return 1;
497	}
498		484
499	if (!boot_device) {
500	puts("\n No boot device \n");
501	SHOW_BOOT_PROGRESS(-1);
502	return 1;
503	}
504
505	dev = simple_strtoul(boot_device, &ep, 16);
506
507	if (dev < 0 \|\| dev >= CFG_MAX_NAND_DEVICE \|\| !nand_info[dev].name) {
508	printf("\n** Device %d not available\n", dev);
509	SHOW_BOOT_PROGRESS(-1);
510	return 1;
511	}
512
513	nand = &nand_info[dev];
514	printf("\nLoading from device %d: %s (offset 0x%lx)\n",
515	dev, nand->name, offset);
516
517	cnt = nand->oobblock;	485	cnt = nand->oobblock;
518	r = nand_read(nand, offset, &cnt, (u_char *) addr);	486	r = nand_read(nand, offset, &cnt, (u_char *) addr);
519	if (r) {	487	if (r) {
520	printf("** Read error on %d\n", dev);	488	puts("** Read error\n");
521	SHOW_BOOT_PROGRESS(-1);	489	SHOW_BOOT_PROGRESS(-1);
522	return 1;	490	return 1;
523	}	491	}
524		492
525	hdr = (image_header_t *) addr;	493	hdr = (image_header_t *) addr;
526		494
527	if (ntohl(hdr->ih_magic) != IH_MAGIC) {	495	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
528	printf("\n Bad Magic Number 0x%x \n", hdr->ih_magic);	496	printf("\n Bad Magic Number 0x%x \n", hdr->ih_magic);
529	SHOW_BOOT_PROGRESS(-1);	497	SHOW_BOOT_PROGRESS(-1);
530	return 1;	498	return 1;
531	}	499	}
532		500
533	print_image_hdr(hdr);	501	print_image_hdr(hdr);
534		502
535	cnt = (ntohl(hdr->ih_size) + sizeof (image_header_t));	503	cnt = (ntohl(hdr->ih_size) + sizeof (image_header_t));
536		504
537	r = nand_read(nand, offset, &cnt, (u_char *) addr);	505	r = nand_read(nand, offset, &cnt, (u_char *) addr);
538	if (r) {	506	if (r) {
539	printf("** Read error on %d\n", dev);	507	puts("** Read error\n");
540	SHOW_BOOT_PROGRESS(-1);	508	SHOW_BOOT_PROGRESS(-1);
541	return 1;	509	return 1;
542	}	510	}
543		511
544	/* Loading ok, update default load address */	512	/* Loading ok, update default load address */
545		513
546	load_addr = addr;	514	load_addr = addr;
547		515
548	/* Check if we should attempt an auto-start */	516	/* Check if we should attempt an auto-start */
549	if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {	517	if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
550	char *local_args[2];	518	char *local_args[2];
551	extern int do_bootm(cmd_tbl_t , int, int, char []);	519	extern int do_bootm(cmd_tbl_t , int, int, char []);
552		520
553	local_args[0] = argv[0];	521	local_args[0] = cmd;
554	local_args[1] = NULL;	522	local_args[1] = NULL;
555		523
556	printf("Automatic boot of image at addr 0x%08lx ...\n", addr);	524	printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
557		525
558	do_bootm(cmdtp, 0, 1, local_args);	526	do_bootm(cmdtp, 0, 1, local_args);
559	return 1;	527	return 1;
560	}	528	}
561	return 0;	529	return 0;
562	}	530	}
563		531
564	U_BOOT_CMD(nboot, 4, 1, do_nandboot,	532	int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
565	"nboot - boot from NAND device\n", "loadAddr dev\n");	533	{
		534	char *boot_device = NULL;
		535	int idx;
		536	ulong addr, offset = 0;
		537	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
		538	struct mtd_device *dev;
		539	struct part_info *part;
		540	u8 pnum;
566		541
		542	if (argc >= 2) {
		543	char *p = (argc == 2) ? argv[1] : argv[2];
		544	if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
		545	(find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
		546	if (dev->id->type != MTD_DEV_TYPE_NAND) {
		547	puts("Not a NAND device\n");
		548	return 1;
		549	}
		550	if (argc > 3)
		551	goto usage;
		552	if (argc == 3)
		553	addr = simple_strtoul(argv[2], NULL, 16);
		554	else
		555	addr = CFG_LOAD_ADDR;
		556	return nand_load_image(cmdtp, &nand_info[dev->id->num],
		557	part->offset, addr, argv[0]);
		558	}
		559	}
		560	#endif
		561
		562	switch (argc) {
		563	case 1:
		564	addr = CFG_LOAD_ADDR;
		565	boot_device = getenv("bootdevice");
		566	break;
		567	case 2:
		568	addr = simple_strtoul(argv[1], NULL, 16);
		569	boot_device = getenv("bootdevice");
		570	break;
		571	case 3:
		572	addr = simple_strtoul(argv[1], NULL, 16);
		573	boot_device = argv[2];
		574	break;
		575	case 4:
		576	addr = simple_strtoul(argv[1], NULL, 16);
		577	boot_device = argv[2];
		578	offset = simple_strtoul(argv[3], NULL, 16);
		579	break;
		580	default:
		581	#if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
		582	usage:
		583	#endif
		584	printf("Usage:\n%s\n", cmdtp->usage);
		585	SHOW_BOOT_PROGRESS(-1);
		586	return 1;
		587	}
		588
		589	if (!boot_device) {
		590	puts("\n No boot device \n");
		591	SHOW_BOOT_PROGRESS(-1);
		592	return 1;
		593	}
		594
		595	idx = simple_strtoul(boot_device, NULL, 16);
		596
		597	if (idx < 0 \|\| idx >= CFG_MAX_NAND_DEVICE \|\| !nand_info[idx].name) {
		598	printf("\n** Device %d not available\n", idx);
		599	SHOW_BOOT_PROGRESS(-1);
		600	return 1;
		601	}
		602
		603	return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
		604	}
		605
		606	U_BOOT_CMD(nboot, 4, 1, do_nandboot,
		607	"nboot - boot from NAND device\n",
		608	"[partition] \| [[[loadAddr] dev] offset]\n");
567		609
568	#endif /* (CONFIG_COMMANDS & CFG_CMD_NAND) */	610	#endif /* (CONFIG_COMMANDS & CFG_CMD_NAND) */
569		611
570	#else /* CFG_NAND_LEGACY */	612	#else /* CFG_NAND_LEGACY */
571	/*	613	/*
572	*	614	*
573	* Legacy NAND support - to be phased out	615	* Legacy NAND support - to be phased out
574	*	616	*
575	*/	617	*/
576	#include <command.h>	618	#include <command.h>
577	#include <malloc.h>	619	#include <malloc.h>
578	#include <asm/io.h>	620	#include <asm/io.h>
579	#include <watchdog.h>	621	#include <watchdog.h>
580		622
581	#ifdef CONFIG_SHOW_BOOT_PROGRESS	623	#ifdef CONFIG_SHOW_BOOT_PROGRESS
582	# include <status_led.h>	624	# include <status_led.h>
583	# define SHOW_BOOT_PROGRESS(arg) show_boot_progress(arg)	625	# define SHOW_BOOT_PROGRESS(arg) show_boot_progress(arg)
584	#else	626	#else
585	# define SHOW_BOOT_PROGRESS(arg)	627	# define SHOW_BOOT_PROGRESS(arg)
586	#endif	628	#endif
587		629
588	#if (CONFIG_COMMANDS & CFG_CMD_NAND)	630	#if (CONFIG_COMMANDS & CFG_CMD_NAND)
589	#include <linux/mtd/nand_legacy.h>	631	#include <linux/mtd/nand_legacy.h>
590	#if 0	632	#if 0
591	#include <linux/mtd/nand_ids.h>	633	#include <linux/mtd/nand_ids.h>
592	#include <jffs2/jffs2.h>	634	#include <jffs2/jffs2.h>
593	#endif	635	#endif
594		636
595	#ifdef CONFIG_OMAP1510	637	#ifdef CONFIG_OMAP1510
596	void archflashwp(void *archdata, int wp);	638	void archflashwp(void *archdata, int wp);
597	#endif	639	#endif
598		640
599	#define ROUND_DOWN(value,boundary) ((value) & (~((boundary)-1)))	641	#define ROUND_DOWN(value,boundary) ((value) & (~((boundary)-1)))
600		642
601	#undef NAND_DEBUG	643	#undef NAND_DEBUG
602	#undef PSYCHO_DEBUG	644	#undef PSYCHO_DEBUG
603		645
604	/* **************** WARNING *******************	646	/* **************** WARNING *******************
605	* When ALLOW_ERASE_BAD_DEBUG is non-zero the erase command will	647	* When ALLOW_ERASE_BAD_DEBUG is non-zero the erase command will
606	* erase (or at least attempt to erase) blocks that are marked	648	* erase (or at least attempt to erase) blocks that are marked
607	* bad. This can be very handy if you are _sure_ that the block	649	* bad. This can be very handy if you are _sure_ that the block
608	* is OK, say because you marked a good block bad to test bad	650	* is OK, say because you marked a good block bad to test bad
609	* block handling and you are done testing, or if you have	651	* block handling and you are done testing, or if you have
610	* accidentally marked blocks bad.	652	* accidentally marked blocks bad.
611	*	653	*
612	* Erasing factory marked bad blocks is a _bad_ idea. If the	654	* Erasing factory marked bad blocks is a _bad_ idea. If the
613	* erase succeeds there is no reliable way to find them again,	655	* erase succeeds there is no reliable way to find them again,
614	* and attempting to program or erase bad blocks can affect	656	* and attempting to program or erase bad blocks can affect
615	* the data in _other_ (good) blocks.	657	* the data in _other_ (good) blocks.
616	*/	658	*/
617	#define ALLOW_ERASE_BAD_DEBUG 0	659	#define ALLOW_ERASE_BAD_DEBUG 0
618		660
619	#define CONFIG_MTD_NAND_ECC /* enable ECC */	661	#define CONFIG_MTD_NAND_ECC /* enable ECC */
620	#define CONFIG_MTD_NAND_ECC_JFFS2	662	#define CONFIG_MTD_NAND_ECC_JFFS2
621		663
622	/* bits for nand_legacy_rw() `cmd'; or together as needed */	664	/* bits for nand_legacy_rw() `cmd'; or together as needed */
623	#define NANDRW_READ 0x01	665	#define NANDRW_READ 0x01
624	#define NANDRW_WRITE 0x00	666	#define NANDRW_WRITE 0x00
625	#define NANDRW_JFFS2 0x02	667	#define NANDRW_JFFS2 0x02
626	#define NANDRW_JFFS2_SKIP 0x04	668	#define NANDRW_JFFS2_SKIP 0x04
627		669
628	/*	670	/*
629	* Imports from nand_legacy.c	671	* Imports from nand_legacy.c
630	*/	672	*/
631	extern struct nand_chip nand_dev_desc[CFG_MAX_NAND_DEVICE];	673	extern struct nand_chip nand_dev_desc[CFG_MAX_NAND_DEVICE];
632	extern int curr_device;	674	extern int curr_device;
633	extern int nand_legacy_erase(struct nand_chip *nand, size_t ofs,	675	extern int nand_legacy_erase(struct nand_chip *nand, size_t ofs,
634	size_t len, int clean);	676	size_t len, int clean);
635	extern int nand_legacy_rw(struct nand_chip *nand, int cmd, size_t start,	677	extern int nand_legacy_rw(struct nand_chip *nand, int cmd, size_t start,
636	size_t len, size_t retlen, u_char buf);	678	size_t len, size_t retlen, u_char buf);
637	extern void nand_print(struct nand_chip *nand);	679	extern void nand_print(struct nand_chip *nand);
638	extern void nand_print_bad(struct nand_chip *nand);	680	extern void nand_print_bad(struct nand_chip *nand);
639	extern int nand_read_oob(struct nand_chip *nand, size_t ofs,	681	extern int nand_read_oob(struct nand_chip *nand, size_t ofs,
640	size_t len, size_t retlen, u_char buf);	682	size_t len, size_t retlen, u_char buf);
641	extern int nand_write_oob(struct nand_chip *nand, size_t ofs,	683	extern int nand_write_oob(struct nand_chip *nand, size_t ofs,
642	size_t len, size_t retlen, const u_char buf);	684	size_t len, size_t retlen, const u_char buf);
643		685
644		686
645	int do_nand (cmd_tbl_t cmdtp, int flag, int argc, char argv[])	687	int do_nand (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
646	{	688	{
647	int rcode = 0;	689	int rcode = 0;
648		690
649	switch (argc) {	691	switch (argc) {
650	case 0:	692	case 0:
651	case 1:	693	case 1:
652	printf ("Usage:\n%s\n", cmdtp->usage);	694	printf ("Usage:\n%s\n", cmdtp->usage);
653	return 1;	695	return 1;
654	case 2:	696	case 2:
655	if (strcmp(argv[1],"info") == 0) {	697	if (strcmp(argv[1],"info") == 0) {
656	int i;	698	int i;
657		699
658	putc ('\n');	700	putc ('\n');
659		701
660	for (i=0; i<CFG_MAX_NAND_DEVICE; ++i) {	702	for (i=0; i<CFG_MAX_NAND_DEVICE; ++i) {
661	if(nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN)	703	if(nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN)
662	continue; /* list only known devices */	704	continue; /* list only known devices */
663	printf ("Device %d: ", i);	705	printf ("Device %d: ", i);
664	nand_print(&nand_dev_desc[i]);	706	nand_print(&nand_dev_desc[i]);
665	}	707	}
666	return 0;	708	return 0;
667		709
668	} else if (strcmp(argv[1],"device") == 0) {	710	} else if (strcmp(argv[1],"device") == 0) {
669	if ((curr_device < 0) \|\| (curr_device >= CFG_MAX_NAND_DEVICE)) {	711	if ((curr_device < 0) \|\| (curr_device >= CFG_MAX_NAND_DEVICE)) {
670	puts ("\nno devices available\n");	712	puts ("\nno devices available\n");
671	return 1;	713	return 1;
672	}	714	}
673	printf ("\nDevice %d: ", curr_device);	715	printf ("\nDevice %d: ", curr_device);
674	nand_print(&nand_dev_desc[curr_device]);	716	nand_print(&nand_dev_desc[curr_device]);
675	return 0;	717	return 0;
676		718
677	} else if (strcmp(argv[1],"bad") == 0) {	719	} else if (strcmp(argv[1],"bad") == 0) {
678	if ((curr_device < 0) \|\| (curr_device >= CFG_MAX_NAND_DEVICE)) {	720	if ((curr_device < 0) \|\| (curr_device >= CFG_MAX_NAND_DEVICE)) {
679	puts ("\nno devices available\n");	721	puts ("\nno devices available\n");
680	return 1;	722	return 1;
681	}	723	}
682	printf ("\nDevice %d bad blocks:\n", curr_device);	724	printf ("\nDevice %d bad blocks:\n", curr_device);
683	nand_print_bad(&nand_dev_desc[curr_device]);	725	nand_print_bad(&nand_dev_desc[curr_device]);
684	return 0;	726	return 0;
685		727
686	}	728	}
687	printf ("Usage:\n%s\n", cmdtp->usage);	729	printf ("Usage:\n%s\n", cmdtp->usage);
688	return 1;	730	return 1;
689	case 3:	731	case 3:
690	if (strcmp(argv[1],"device") == 0) {	732	if (strcmp(argv[1],"device") == 0) {
691	int dev = (int)simple_strtoul(argv[2], NULL, 10);	733	int dev = (int)simple_strtoul(argv[2], NULL, 10);
692		734
693	printf ("\nDevice %d: ", dev);	735	printf ("\nDevice %d: ", dev);
694	if (dev >= CFG_MAX_NAND_DEVICE) {	736	if (dev >= CFG_MAX_NAND_DEVICE) {
695	puts ("unknown device\n");	737	puts ("unknown device\n");
696	return 1;	738	return 1;
697	}	739	}
698	nand_print(&nand_dev_desc[dev]);	740	nand_print(&nand_dev_desc[dev]);
699	/nand_print (dev);/	741	/nand_print (dev);/
700		742
701	if (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN) {	743	if (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN) {
702	return 1;	744	return 1;
703	}	745	}
704		746
705	curr_device = dev;	747	curr_device = dev;
706		748
707	puts ("... is now current device\n");	749	puts ("... is now current device\n");
708		750
709	return 0;	751	return 0;
710	}	752	}
711	else if (strcmp(argv[1],"erase") == 0 && strcmp(argv[2], "clean") == 0) {	753	else if (strcmp(argv[1],"erase") == 0 && strcmp(argv[2], "clean") == 0) {
712	struct nand_chip* nand = &nand_dev_desc[curr_device];	754	struct nand_chip* nand = &nand_dev_desc[curr_device];
713	ulong off = 0;	755	ulong off = 0;
714	ulong size = nand->totlen;	756	ulong size = nand->totlen;
715	int ret;	757	int ret;
716		758
717	printf ("\nNAND erase: device %d offset %ld, size %ld ... ",	759	printf ("\nNAND erase: device %d offset %ld, size %ld ... ",
718	curr_device, off, size);	760	curr_device, off, size);
719		761
720	ret = nand_legacy_erase (nand, off, size, 1);	762	ret = nand_legacy_erase (nand, off, size, 1);
721		763
722	printf("%s\n", ret ? "ERROR" : "OK");	764	printf("%s\n", ret ? "ERROR" : "OK");
723		765
724	return ret;	766	return ret;
725	}	767	}
726		768
727	printf ("Usage:\n%s\n", cmdtp->usage);	769	printf ("Usage:\n%s\n", cmdtp->usage);
728	return 1;	770	return 1;
729	default:	771	default:
730	/* at least 4 args */	772	/* at least 4 args */
731		773
732	if (strncmp(argv[1], "read", 4) == 0 \|\|	774	if (strncmp(argv[1], "read", 4) == 0 \|\|
733	strncmp(argv[1], "write", 5) == 0) {	775	strncmp(argv[1], "write", 5) == 0) {
734	ulong addr = simple_strtoul(argv[2], NULL, 16);	776	ulong addr = simple_strtoul(argv[2], NULL, 16);
735	ulong off = simple_strtoul(argv[3], NULL, 16);	777	ulong off = simple_strtoul(argv[3], NULL, 16);
736	ulong size = simple_strtoul(argv[4], NULL, 16);	778	ulong size = simple_strtoul(argv[4], NULL, 16);
737	int cmd = (strncmp(argv[1], "read", 4) == 0) ?	779	int cmd = (strncmp(argv[1], "read", 4) == 0) ?
738	NANDRW_READ : NANDRW_WRITE;	780	NANDRW_READ : NANDRW_WRITE;
739	int ret, total;	781	int ret, total;
740	char* cmdtail = strchr(argv[1], '.');	782	char* cmdtail = strchr(argv[1], '.');
741		783
742	if (cmdtail && !strncmp(cmdtail, ".oob", 2)) {	784	if (cmdtail && !strncmp(cmdtail, ".oob", 2)) {
743	/* read out-of-band data */	785	/* read out-of-band data */
744	if (cmd & NANDRW_READ) {	786	if (cmd & NANDRW_READ) {
745	ret = nand_read_oob(nand_dev_desc + curr_device,	787	ret = nand_read_oob(nand_dev_desc + curr_device,
746	off, size, (size_t *)&total,	788	off, size, (size_t *)&total,
747	(u_char*)addr);	789	(u_char*)addr);
748	}	790	}
749	else {	791	else {
750	ret = nand_write_oob(nand_dev_desc + curr_device,	792	ret = nand_write_oob(nand_dev_desc + curr_device,
751	off, size, (size_t *)&total,	793	off, size, (size_t *)&total,
752	(u_char*)addr);	794	(u_char*)addr);
753	}	795	}
754	return ret;	796	return ret;
755	}	797	}
756	else if (cmdtail && !strncmp(cmdtail, ".jffs2", 2))	798	else if (cmdtail && !strncmp(cmdtail, ".jffs2", 2))
757	cmd \|= NANDRW_JFFS2; /* skip bad blocks */	799	cmd \|= NANDRW_JFFS2; /* skip bad blocks */
758	else if (cmdtail && !strncmp(cmdtail, ".jffs2s", 2)) {	800	else if (cmdtail && !strncmp(cmdtail, ".jffs2s", 2)) {
759	cmd \|= NANDRW_JFFS2; /* skip bad blocks (on read too) */	801	cmd \|= NANDRW_JFFS2; /* skip bad blocks (on read too) */
760	if (cmd & NANDRW_READ)	802	if (cmd & NANDRW_READ)
761	cmd \|= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */	803	cmd \|= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */
762	}	804	}
763	#ifdef SXNI855T	805	#ifdef SXNI855T
764	/* need ".e" same as ".j" for compatibility with older units */	806	/* need ".e" same as ".j" for compatibility with older units */
765	else if (cmdtail && !strcmp(cmdtail, ".e"))	807	else if (cmdtail && !strcmp(cmdtail, ".e"))
766	cmd \|= NANDRW_JFFS2; /* skip bad blocks */	808	cmd \|= NANDRW_JFFS2; /* skip bad blocks */
767	#endif	809	#endif
768	#ifdef CFG_NAND_SKIP_BAD_DOT_I	810	#ifdef CFG_NAND_SKIP_BAD_DOT_I
769	/* need ".i" same as ".jffs2s" for compatibility with older units (esd) */	811	/* need ".i" same as ".jffs2s" for compatibility with older units (esd) */
770	/* ".i" for image -> read skips bad block (no 0xff) */	812	/* ".i" for image -> read skips bad block (no 0xff) */
771	else if (cmdtail && !strcmp(cmdtail, ".i")) {	813	else if (cmdtail && !strcmp(cmdtail, ".i")) {
772	cmd \|= NANDRW_JFFS2; /* skip bad blocks (on read too) */	814	cmd \|= NANDRW_JFFS2; /* skip bad blocks (on read too) */
773	if (cmd & NANDRW_READ)	815	if (cmd & NANDRW_READ)
774	cmd \|= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */	816	cmd \|= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */
775	}	817	}
776	#endif /* CFG_NAND_SKIP_BAD_DOT_I */	818	#endif /* CFG_NAND_SKIP_BAD_DOT_I */
777	else if (cmdtail) {	819	else if (cmdtail) {
778	printf ("Usage:\n%s\n", cmdtp->usage);	820	printf ("Usage:\n%s\n", cmdtp->usage);
779	return 1;	821	return 1;
780	}	822	}
781		823
782	printf ("\nNAND %s: device %d offset %ld, size %ld ...\n",	824	printf ("\nNAND %s: device %d offset %ld, size %ld ...\n",
783	(cmd & NANDRW_READ) ? "read" : "write",	825	(cmd & NANDRW_READ) ? "read" : "write",
784	curr_device, off, size);	826	curr_device, off, size);
785		827
786	ret = nand_legacy_rw(nand_dev_desc + curr_device, cmd, off, size,	828	ret = nand_legacy_rw(nand_dev_desc + curr_device, cmd, off, size,
787	(size_t )&total, (u_char)addr);	829	(size_t )&total, (u_char)addr);
788		830
789	printf (" %d bytes %s: %s\n", total,	831	printf (" %d bytes %s: %s\n", total,
790	(cmd & NANDRW_READ) ? "read" : "written",	832	(cmd & NANDRW_READ) ? "read" : "written",
791	ret ? "ERROR" : "OK");	833	ret ? "ERROR" : "OK");
792		834
793	return ret;	835	return ret;
794	} else if (strcmp(argv[1],"erase") == 0 &&	836	} else if (strcmp(argv[1],"erase") == 0 &&
795	(argc == 4 \|\| strcmp("clean", argv[2]) == 0)) {	837	(argc == 4 \|\| strcmp("clean", argv[2]) == 0)) {
796	int clean = argc == 5;	838	int clean = argc == 5;
797	ulong off = simple_strtoul(argv[2 + clean], NULL, 16);	839	ulong off = simple_strtoul(argv[2 + clean], NULL, 16);
798	ulong size = simple_strtoul(argv[3 + clean], NULL, 16);	840	ulong size = simple_strtoul(argv[3 + clean], NULL, 16);
799	int ret;	841	int ret;
800		842
801	printf ("\nNAND erase: device %d offset %ld, size %ld ...\n",	843	printf ("\nNAND erase: device %d offset %ld, size %ld ...\n",
802	curr_device, off, size);	844	curr_device, off, size);
803		845
804	ret = nand_legacy_erase (nand_dev_desc + curr_device,	846	ret = nand_legacy_erase (nand_dev_desc + curr_device,
805	off, size, clean);	847	off, size, clean);
806		848
807	printf("%s\n", ret ? "ERROR" : "OK");	849	printf("%s\n", ret ? "ERROR" : "OK");
808		850
809	return ret;	851	return ret;
810	} else {	852	} else {
811	printf ("Usage:\n%s\n", cmdtp->usage);	853	printf ("Usage:\n%s\n", cmdtp->usage);
812	rcode = 1;	854	rcode = 1;
813	}	855	}
814		856
815	return rcode;	857	return rcode;
816	}	858	}
817	}	859	}
818		860
819	U_BOOT_CMD(	861	U_BOOT_CMD(
820	nand, 5, 1, do_nand,	862	nand, 5, 1, do_nand,
821	"nand - legacy NAND sub-system\n",	863	"nand - legacy NAND sub-system\n",
822	"info - show available NAND devices\n"	864	"info - show available NAND devices\n"
823	"nand device [dev] - show or set current device\n"	865	"nand device [dev] - show or set current device\n"
824	"nand read[.jffs2[s]] addr off size\n"	866	"nand read[.jffs2[s]] addr off size\n"
825	"nand write[.jffs2] addr off size - read/write `size' bytes starting\n"	867	"nand write[.jffs2] addr off size - read/write `size' bytes starting\n"
826	" at offset `off' to/from memory address `addr'\n"	868	" at offset `off' to/from memory address `addr'\n"
827	"nand erase [clean] [off size] - erase `size' bytes from\n"	869	"nand erase [clean] [off size] - erase `size' bytes from\n"
828	" offset `off' (entire device if not specified)\n"	870	" offset `off' (entire device if not specified)\n"
829	"nand bad - show bad blocks\n"	871	"nand bad - show bad blocks\n"
830	"nand read.oob addr off size - read out-of-band data\n"	872	"nand read.oob addr off size - read out-of-band data\n"
831	"nand write.oob addr off size - read out-of-band data\n"	873	"nand write.oob addr off size - read out-of-band data\n"
832	);	874	);
833		875
834	int do_nandboot (cmd_tbl_t cmdtp, int flag, int argc, char argv[])	876	int do_nandboot (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
835	{	877	{
836	char *boot_device = NULL;	878	char *boot_device = NULL;
837	char *ep;	879	char *ep;
838	int dev;	880	int dev;
839	ulong cnt;	881	ulong cnt;
840	ulong addr;	882	ulong addr;
841	ulong offset = 0;	883	ulong offset = 0;
842	image_header_t *hdr;	884	image_header_t *hdr;
843	int rcode = 0;	885	int rcode = 0;
844	switch (argc) {	886	switch (argc) {
845	case 1:	887	case 1:
846	addr = CFG_LOAD_ADDR;	888	addr = CFG_LOAD_ADDR;
847	boot_device = getenv ("bootdevice");	889	boot_device = getenv ("bootdevice");
848	break;	890	break;
849	case 2:	891	case 2:
850	addr = simple_strtoul(argv[1], NULL, 16);	892	addr = simple_strtoul(argv[1], NULL, 16);
851	boot_device = getenv ("bootdevice");	893	boot_device = getenv ("bootdevice");
852	break;	894	break;
853	case 3:	895	case 3:
854	addr = simple_strtoul(argv[1], NULL, 16);	896	addr = simple_strtoul(argv[1], NULL, 16);
855	boot_device = argv[2];	897	boot_device = argv[2];
856	break;	898	break;
857	case 4:	899	case 4:

cpu/arm925t/omap925.c

Diff comments View file @ d983189

 /*
  * (C) Copyright 2003
  * Texas Instruments <www.ti.com>
  *
  * 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 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., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #include <common.h>
 #include <command.h>
 #include <arm925t.h>
-ushort gpioreserved;
-void gpioreserve(ushort mask)
-{
-	gpioreserved |= mask;
-}
-void gpiosetdir(ushort mask, ushort in)
-{
-	*(ushort *)GPIO_DIR_CONTROL_REG = (*(ushort *)GPIO_DIR_CONTROL_REG & ~mask) | (in & mask);
-}
-void gpiosetout(ushort mask, ushort out)
-{
-	ushort *r_ptr, r_val;
-	r_ptr = (ushort *)GPIO_DATA_OUTPUT_REG;	/* set pointer */
-	r_val = *r_ptr & ~mask;		/* get previous val, clear bits we want to change */
-	r_val |= (out & mask);		/* set specified bits in value + plus origional ones */
-	*r_ptr = r_val;			/* write it out */
-/*
- * gcc screwed this one up :(.
- *
- * *(ushort *)GPIO_DATA_OUTPUT_REG = (*(ushort *)GPIO_DATA_OUTPUT_REG & ~mask) | (out & mask);
- */
-}
-void gpioinit(void)
-{
-}
 #define MIF_CONFIG_REG 0xFFFECC0C
 #define FLASH_GLOBAL_CTRL_NWP 1
 void archflashwp (void *archdata, int wp)
 {
 	ulong *fgc = (ulong *) MIF_CONFIG_REG;
 	if (wp == 1)
 		*fgc &= ~FLASH_GLOBAL_CTRL_NWP;
 	else
 		*fgc |= FLASH_GLOBAL_CTRL_NWP;
 }

doc/README.nand

Diff comments View file @ d983189

 NAND FLASH commands and notes
 See NOTE below!!!
 # (C) Copyright 2003
 # Dave Ellis, SIXNET, dge@sixnetio.com
 #
 # 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 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., 59 Temple Place, Suite 330, Boston,
 # MA 02111-1307 USA
 Commands:
    nand bad
       Print a list of all of the bad blocks in the current device.
    nand device
       Print information about the current NAND device.
    nand device num
       Make device `num' the current device and print information about it.
-   nand erase off size
+   nand erase off|partition size
-   nand erase clean [off size]
+   nand erase clean [off|partition size]
-      Erase `size' bytes starting at offset `off'.  Only complete erase
+      Erase `size' bytes starting at offset `off'. Alternatively partition
-      blocks can be erased.
+      name can be specified, in this case size will be eventually limited
+      to not exceed partition size (this behaviour applies also to read
+      and write commands). Only complete erase blocks can be erased.
+      If `erase' is specified without an offset or size, the entire flash
+      is erased. If `erase' is specified with partition but without an
+      size, the entire partition is erased.
       If `clean' is specified, a JFFS2-style clean marker is written to
-      each block after it is erased. If `clean' is specified without an
+      each block after it is erased.
-      offset or size, the entire flash is erased.
       This command will not erase blocks that are marked bad. There is
       a debug option in cmd_nand.c to allow bad blocks to be erased.
       Please read the warning there before using it, as blocks marked
       bad by the manufacturer must _NEVER_ be erased.
    nand info
       Print information about all of the NAND devices found.
-   nand read addr ofs size
+   nand read addr ofs|partition size
       Read `size' bytes from `ofs' in NAND flash to `addr'. If a page
       cannot be read because it is marked bad or an uncorrectable data
       error is found the command stops with an error.
-   nand read.jffs2 addr ofs size
+   nand read.jffs2 addr ofs|partition size
       Like `read', but the data for blocks that are marked bad is read as
       0xff. This gives a readable JFFS2 image that can be processed by
       the JFFS2 commands such as ls and fsload.
-   nand read.oob addr ofs size
+   nand read.oob addr ofs|partition size
       Read `size' bytes from the out-of-band data area corresponding to
       `ofs' in NAND flash to `addr'. This is limited to the 16 bytes of
       data for one 512-byte page or 2 256-byte pages. There is no check
       for bad blocks or ECC errors.
-   nand write addr ofs size
+   nand write addr ofs|partition size
       Write `size' bytes from `addr' to `ofs' in NAND flash. If a page
       cannot be written because it is marked bad or the write fails the
       command stops with an error.
-   nand write.jffs2 addr ofs size
+   nand write.jffs2 addr ofs|partition size
       Like `write', but blocks that are marked bad are skipped and the
       is written to the next block instead. This allows writing writing
       a JFFS2 image, as long as the image is short enough to fit even
       after skipping the bad blocks. Compact images, such as those
       produced by mkfs.jffs2 should work well, but loading an image copied
       from another flash is going to be trouble if there are any bad blocks.
-   nand write.oob addr ofs size
+   nand write.oob addr ofs|partition size
       Write `size' bytes from `addr' to the out-of-band data area
       corresponding to `ofs' in NAND flash. This is limited to the 16 bytes
       of data for one 512-byte page or 2 256-byte pages. There is no check
       for bad blocks.
 Configuration Options:
    CFG_CMD_NAND
       A good one to add to CONFIG_COMMANDS since it enables NAND support.
    CONFIG_MTD_NAND_ECC_JFFS2
       Define this if you want the Error Correction Code information in
       the out-of-band data to be formatted to match the JFFS2 file system.
       CONFIG_MTD_NAND_ECC_YAFFS would be another useful choice for
       someone to implement.
    CFG_MAX_NAND_DEVICE
       The maximum number of NAND devices you want to support.
 NAND Interface:
    #define NAND_WAIT_READY(nand)
       Wait until the NAND flash is ready. Typically this would be a
       loop waiting for the READY/BUSY line from the flash to indicate it
       it is ready.
    #define WRITE_NAND_COMMAND(d, adr)
       Write the command byte `d' to the flash at `adr' with the
       CLE (command latch enable) line true. If your board uses writes to
       different addresses to control CLE and ALE, you can modify `adr'
       to be the appropriate address here. If your board uses I/O registers
       to control them, it is probably better to let NAND_CTL_SETCLE()
       and company do it.
    #define WRITE_NAND_ADDRESS(d, adr)
       Write the address byte `d' to the flash at `adr' with the
       ALE (address latch enable) line true. If your board uses writes to
       different addresses to control CLE and ALE, you can modify `adr'
       to be the appropriate address here. If your board uses I/O registers
       to control them, it is probably better to let NAND_CTL_SETALE()
       and company do it.
    #define WRITE_NAND(d, adr)
       Write the data byte `d' to the flash at `adr' with the
       ALE and CLE lines false. If your board uses writes to
       different addresses to control CLE and ALE, you can modify `adr'
       to be the appropriate address here. If your board uses I/O registers
       to control them, it is probably better to let NAND_CTL_CLRALE()
       and company do it.
    #define READ_NAND(adr)
       Read a data byte from the flash at `adr' with the
       ALE and CLE lines false. If your board uses reads from
       different addresses to control CLE and ALE, you can modify `adr'
       to be the appropriate address here. If your board uses I/O registers
       to control them, it is probably better to let NAND_CTL_CLRALE()
       and company do it.
    #define NAND_DISABLE_CE(nand)
       Set CE (Chip Enable) low to enable the NAND flash.
    #define NAND_ENABLE_CE(nand)
       Set CE (Chip Enable) high to disable the NAND flash.
    #define NAND_CTL_CLRALE(nandptr)
       Set ALE (address latch enable) low. If ALE control is handled by
       WRITE_NAND_ADDRESS() this can be empty.
    #define NAND_CTL_SETALE(nandptr)
       Set ALE (address latch enable) high. If ALE control is handled by
       WRITE_NAND_ADDRESS() this can be empty.
    #define NAND_CTL_CLRCLE(nandptr)
       Set CLE (command latch enable) low. If CLE control is handled by
       WRITE_NAND_ADDRESS() this can be empty.
    #define NAND_CTL_SETCLE(nandptr)
       Set CLE (command latch enable) high. If CLE control is handled by
       WRITE_NAND_ADDRESS() this can be empty.
 More Definitions:
    These definitions are needed in the board configuration for now, but
    may really belong in a header file.
    TODO: Figure which ones are truly configuration settings and rename
 	 them to CFG_NAND_... and move the rest somewhere appropriate.
    #define SECTORSIZE 512
    #define ADDR_COLUMN 1
    #define ADDR_PAGE 2
    #define ADDR_COLUMN_PAGE 3
    #define NAND_ChipID_UNKNOWN 0x00
    #define NAND_MAX_FLOORS 1
    #define NAND_MAX_CHIPS 1
 NOTE:
 =====
 We now use a complete rewrite of the NAND code based on what is in
 2.6.12 Linux kernel.
 The old NAND handling code has been re-factored and is now confined
 to only board-specific files and - unfortunately - to the DoC code
 (see below). A new configuration variable has been introduced:
 CFG_NAND_LEGACY, which has to be defined in the board config file if
 that board uses legacy code. If CFG_NAND_LEGACY is defined, the board
 specific config.mk file should also have "BOARDLIBS =
 drivers/nand_legacy/libnand_legacy.a". For boards using the new NAND
 approach (PPChameleon and netstar at the moment) no variable is
 necessary, but the config.mk should have "BOARDLIBS =
 drivers/nand/libnand.a".
 The necessary changes have been made to all affected boards, and no
 build breakage has been introduced, except for NETTA and NETTA_ISDN
 targets from MAKEALL. This is due to the fact that these two boards
 use JFFS, which has been adopted to use the new NAND, and at the same
 time use NAND in legacy mode. The breakage will disappear when the
 board-specific code is changed to the new NAND.
 As mentioned above, the legacy code is still used by the DoC subsystem.
 The consequence of this is that the legacy NAND can't be removed  from
 the tree until the DoC is ported to use the new NAND support (or boards
 with DoC will break).
 Additional improvements to the NAND subsystem by Guido Classen, 10-10-2006
 JFFS2 related commands:
   implement "nand erase clean" and old "nand erase"
   using both the new code which is able to skip bad blocks
   "nand erase clean" additionally writes JFFS2-cleanmarkers in the oob.
   "nand write.jffs2"
   like "nand write" but skip found bad eraseblocks
   "nand read.jffs2"
   like "nand read" but skip found bad eraseblocks
 Miscellaneous and testing commands:
   "markbad [offset]"
   create an artificial bad block (for testing bad block handling)
   "scrub [offset length]"
   like "erase" but don't skip bad block. Instead erase them.
   DANGEROUS!!! Factory set bad blocks will be lost. Use only
   to remove artificial bad blocks created with the "markbad" command.
 NAND locking command (for chips with active LOCKPRE pin)
   "nand lock"
   set NAND chip to lock state (all pages locked)
   "nand lock tight"
   set NAND chip to lock tight state (software can't change locking anymore)
   "nand lock status"
   displays current locking status of all pages
   "nand unlock [offset] [size]"
   unlock consecutive area (can be called multiple times for different areas)
 I have tested the code with board containing 128MiB NAND large page chips
 and 32MiB small page chips.

drivers/nand/nand_util.c

Diff comments View file @ d983189

 /*
  * drivers/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>
 #if (CONFIG_COMMANDS & CFG_CMD_NAND) && !defined(CFG_NAND_LEGACY)
 #include <command.h>
 #include <watchdog.h>
 #include <malloc.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;
 	int clmpos = 0;
 	int clmlen = 8;
 	erase_info_t erase;
 	ulong erase_length;
 	int isNAND;
 	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;
 	memset(&erase, 0, sizeof(erase));
 	erase.mtd = meminfo;
 	erase.len  = meminfo->erasesize;
-	if (opts->offset == 0 && opts->length == 0) {
+	erase.addr = opts->offset;
-		/* erase complete chip */
+	erase_length = opts->length;
-		erase.addr = 0;
-		erase_length = meminfo->size;
-	} else {
-		/* erase specified region */
-		erase.addr = opts->offset;
-		erase_length = opts->length;
-	}
 	isNAND = meminfo->type == MTD_NANDFLASH ? 1 : 0;
 	if (opts->jffs2) {
 		cleanmarker.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
 		cleanmarker.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
 		if (isNAND) {
 			struct nand_oobinfo *oobinfo = &meminfo->oobinfo;
 			/* check for autoplacement */
 			if (oobinfo->useecc == MTD_NANDECC_AUTOPLACE) {
 				/* get the position of the free bytes */
 				if (!oobinfo->oobfree[0][1]) {
 					printf(" Eeep. Autoplacement selected "
 					       "and no empty space in oob\n");
 					return -1;
 				}
 				clmpos = oobinfo->oobfree[0][0];
 				clmlen = oobinfo->oobfree[0][1];
 				if (clmlen > 8)
 					clmlen = 8;
 			} else {
 				/* legacy mode */
 				switch (meminfo->oobsize) {
 				case 8:
 					clmpos = 6;
 					clmlen = 2;
 					break;
 				case 16:
 					clmpos = 8;
 					clmlen = 8;
 					break;
 				case 64:
 					clmpos = 16;
 					clmlen = 8;
 					break;
 				}
 			}
 			cleanmarker.totlen = cpu_to_je32(8);
 		} else {
 			cleanmarker.totlen =
 				cpu_to_je32(sizeof(struct jffs2_unknown_node));
 		}
 		cleanmarker.hdr_crc =  cpu_to_je32(
 			crc32_no_comp(0, (unsigned char *) &cleanmarker,
 				      sizeof(struct jffs2_unknown_node) - 4));
 	}
 	/* 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;
 	}
 	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) {
 			/* write cleanmarker */
 			if (isNAND) {
 				size_t written;
 				result = meminfo->write_oob(meminfo,
 							    erase.addr + clmpos,
 							    clmlen,
 							    &written,
 							    (unsigned char *)
 							    &cleanmarker);
 				if (result != 0) {
 					printf("\n%s: MTD writeoob failure: %d\n",
 					       mtd_device, result);
 					continue;
 				}
 			} else {
 				printf("\n%s: this erase routine only supports"
 				       " NAND devices!\n",
 				       mtd_device);
 			}
 		}
 		if (!opts->quiet) {
 			int percent = (int)
 				((unsigned long long)
 				 (erase.addr+meminfo->erasesize-opts->offset)
 				 * 100 / erase_length);
 			/* 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;
 }
 #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_oobinfo none_oobinfo = {
 	.useecc = MTD_NANDECC_OFF,
 };
 static struct nand_oobinfo jffs2_oobinfo = {
 	.useecc = MTD_NANDECC_PLACE,
 	.eccbytes = 6,
 	.eccpos = { 0, 1, 2, 3, 6, 7 }
 };
 static struct nand_oobinfo yaffs_oobinfo = {
 	.useecc = MTD_NANDECC_PLACE,
 	.eccbytes = 6,
 	.eccpos = { 8, 9, 10, 13, 14, 15}
 };
 static struct nand_oobinfo autoplace_oobinfo = {
 	.useecc = MTD_NANDECC_AUTOPLACE
 };
 /**
  * nand_write_opts: - write image to NAND flash with support for various options
  *
  * @param meminfo	NAND device to erase
  * @param opts		write options (@see nand_write_options)
  * @return		0 in case of success
  *
  * This code is ported from nandwrite.c from Linux mtd utils by
  * Steven J. Hill and Thomas Gleixner.
  */
 int nand_write_opts(nand_info_t *meminfo, const nand_write_options_t *opts)
 {
 	int imglen = 0;
 	int pagelen;
 	int baderaseblock;
 	int blockstart = -1;
 	loff_t offs;
 	int readlen;
 	int oobinfochanged = 0;
 	int percent_complete = -1;
 	struct nand_oobinfo old_oobinfo;
 	ulong mtdoffset = opts->offset;
 	ulong erasesize_blockalign;
 	u_char *buffer = opts->buffer;
 	size_t written;
 	int result;
 	if (opts->pad && opts->writeoob) {
 		printf("Can't pad when oob data is present.\n");
 		return -1;
 	}
 	/* set erasesize to specified number of blocks - to match
 	 * jffs2 (virtual) block size */
 	if (opts->blockalign == 0) {
 		erasesize_blockalign = meminfo->erasesize;
 	} else {
 		erasesize_blockalign = meminfo->erasesize * opts->blockalign;
 	}
 	/* make sure device page sizes are valid */
 	if (!(meminfo->oobsize == 16 && meminfo->oobblock == 512)
 	    && !(meminfo->oobsize == 8 && meminfo->oobblock == 256)
 	    && !(meminfo->oobsize == 64 && meminfo->oobblock == 2048)) {
 		printf("Unknown flash (not normal NAND)\n");
 		return -1;
 	}
 	/* read the current oob info */
 	memcpy(&old_oobinfo, &meminfo->oobinfo, sizeof(old_oobinfo));
 	/* write without ecc? */
 	if (opts->noecc) {
 		memcpy(&meminfo->oobinfo, &none_oobinfo,
 		       sizeof(meminfo->oobinfo));
 		oobinfochanged = 1;
 	}
 	/* autoplace ECC? */
 	if (opts->autoplace && (old_oobinfo.useecc != MTD_NANDECC_AUTOPLACE)) {
 		memcpy(&meminfo->oobinfo, &autoplace_oobinfo,
 		       sizeof(meminfo->oobinfo));
 		oobinfochanged = 1;
 	}
 	/* force OOB layout for jffs2 or yaffs? */
 	if (opts->forcejffs2 || opts->forceyaffs) {
 		struct nand_oobinfo *oobsel =
 			opts->forcejffs2 ? &jffs2_oobinfo : &yaffs_oobinfo;
 		if (meminfo->oobsize == 8) {
 			if (opts->forceyaffs) {
 				printf("YAFSS cannot operate on "
 				       "256 Byte page size\n");
 				goto restoreoob;
 			}
 			/* Adjust number of ecc bytes */
 			jffs2_oobinfo.eccbytes = 3;
 		}
 		memcpy(&meminfo->oobinfo, oobsel, sizeof(meminfo->oobinfo));
 	}
 	/* get image length */
 	imglen = opts->length;
 	pagelen = meminfo->oobblock
 		+ ((opts->writeoob != 0) ? meminfo->oobsize : 0);
 	/* check, if file is pagealigned */
 	if ((!opts->pad) && ((imglen % pagelen) != 0)) {
 		printf("Input block length is not page aligned\n");
 		goto restoreoob;
 	}
 	/* check, if length fits into device */
 	if (((imglen / pagelen) * meminfo->oobblock)
 	     > (meminfo->size - opts->offset)) {
 		printf("Image %d bytes, NAND page %d bytes, "
 		       "OOB area %u bytes, device size %u bytes\n",
 		       imglen, pagelen, meminfo->oobblock, meminfo->size);
 		printf("Input block does not fit into device\n");
 		goto restoreoob;
 	}
 	if (!opts->quiet)
 		printf("\n");
 	/* get data from input and write to the device */
 	while (imglen && (mtdoffset < meminfo->size)) {
 		WATCHDOG_RESET ();
 		/*
 		 * new eraseblock, check for bad block(s). Stay in the
 		 * loop to be sure if the offset changes because of
 		 * a bad block, that the next block that will be
 		 * written to is also checked. Thus avoiding errors if
 		 * the block(s) after the skipped block(s) is also bad
 		 * (number of blocks depending on the blockalign
 		 */
 		while (blockstart != (mtdoffset & (~erasesize_blockalign+1))) {
 			blockstart = mtdoffset & (~erasesize_blockalign+1);
 			offs = blockstart;
 			baderaseblock = 0;
 			/* check all the blocks in an erase block for
 			 * bad blocks */
 			do {
 				int ret = meminfo->block_isbad(meminfo, offs);
 				if (ret < 0) {
 					printf("Bad block check failed\n");
 					goto restoreoob;
 				}
 				if (ret == 1) {
 					baderaseblock = 1;
 					if (!opts->quiet)
 						printf("\rBad block at 0x%lx "
 						       "in erase block from "
 						       "0x%x will be skipped\n",
 						       (long) offs,
 						       blockstart);
 				}
 				if (baderaseblock) {
 					mtdoffset = blockstart
 						+ erasesize_blockalign;
 				}
 				offs +=	 erasesize_blockalign
 					/ opts->blockalign;
 			} while (offs < blockstart + erasesize_blockalign);
 		}
 		readlen = meminfo->oobblock;
 		if (opts->pad && (imglen < readlen)) {
 			readlen = imglen;
 			memset(data_buf + readlen, 0xff,
 			       meminfo->oobblock - readlen);
 		}
 		/* read page data from input memory buffer */
 		memcpy(data_buf, buffer, readlen);
 		buffer += readlen;
 		if (opts->writeoob) {
 			/* read OOB data from input memory block, exit
 			 * on failure */
 			memcpy(oob_buf, buffer, meminfo->oobsize);
 			buffer += meminfo->oobsize;
 			/* write OOB data first, as ecc will be placed
 			 * in there*/
 			result = meminfo->write_oob(meminfo,
 						    mtdoffset,
 						    meminfo->oobsize,
 						    &written,
 						    (unsigned char *)
 						    &oob_buf);
 			if (result != 0) {
 				printf("\nMTD writeoob failure: %d\n",
 				       result);
 				goto restoreoob;
 			}
 			imglen -= meminfo->oobsize;
 		}
 		/* write out the page data */
 		result = meminfo->write(meminfo,
 					mtdoffset,
 					meminfo->oobblock,
 					&written,
 					(unsigned char *) &data_buf);
 		if (result != 0) {
 			printf("writing NAND page at offset 0x%lx failed\n",
 			       mtdoffset);
 			goto restoreoob;
 		}
 		imglen -= readlen;
 		if (!opts->quiet) {
 			int percent = (int)
 				((unsigned long long)
 				 (opts->length-imglen) * 100
 				 / opts->length);
 			/* output progress message only at whole percent
 			 * steps to reduce the number of messages printed
 			 * on (slow) serial consoles
 			 */
 			if (percent != percent_complete) {
 				printf("\rWriting data at 0x%x "
 				       "-- %3d%% complete.",
 				       mtdoffset, percent);
 				percent_complete = percent;
 			}
 		}
 		mtdoffset += meminfo->oobblock;
 	}
 	if (!opts->quiet)
 		printf("\n");
 restoreoob:
 	if (oobinfochanged) {
 		memcpy(&meminfo->oobinfo, &old_oobinfo,
 		       sizeof(meminfo->oobinfo));
 	}
 	if (imglen > 0) {
 		printf("Data did not fit into device, due to bad blocks\n");
 		return -1;
 	}
 	/* return happy */
 	return 0;
 }
 /**
  * nand_read_opts: - read image from NAND flash with support for various options
  *
  * @param meminfo	NAND device to erase
  * @param opts		read options (@see struct nand_read_options)
  * @return		0 in case of success
  *
  */
 int nand_read_opts(nand_info_t *meminfo, const nand_read_options_t *opts)
 {
 	int imglen = opts->length;
 	int pagelen;
 	int baderaseblock;
 	int blockstart = -1;
 	int percent_complete = -1;
 	loff_t offs;
 	size_t readlen;
 	ulong mtdoffset = opts->offset;
 	u_char *buffer = opts->buffer;
 	int result;
 	/* make sure device page sizes are valid */
 	if (!(meminfo->oobsize == 16 && meminfo->oobblock == 512)
 	    && !(meminfo->oobsize == 8 && meminfo->oobblock == 256)
 	    && !(meminfo->oobsize == 64 && meminfo->oobblock == 2048)) {
 		printf("Unknown flash (not normal NAND)\n");
 		return -1;
 	}
 	pagelen = meminfo->oobblock
 		+ ((opts->readoob != 0) ? meminfo->oobsize : 0);
 	/* check, if length is not larger than device */
 	if (((imglen / pagelen) * meminfo->oobblock)
 	     > (meminfo->size - opts->offset)) {
 		printf("Image %d bytes, NAND page %d bytes, "
 		       "OOB area %u bytes, device size %u bytes\n",
 		       imglen, pagelen, meminfo->oobblock, meminfo->size);
 		printf("Input block is larger than device\n");
 		return -1;
 	}
 	if (!opts->quiet)
 		printf("\n");
 	/* get data from input and write to the device */
 	while (imglen && (mtdoffset < meminfo->size)) {
 		WATCHDOG_RESET ();
 		/*
 		 * new eraseblock, check for bad block(s). Stay in the
 		 * loop to be sure if the offset changes because of
 		 * a bad block, that the next block that will be
 		 * written to is also checked. Thus avoiding errors if
 		 * the block(s) after the skipped block(s) is also bad
 		 * (number of blocks depending on the blockalign
 		 */
 		while (blockstart != (mtdoffset & (~meminfo->erasesize+1))) {
 			blockstart = mtdoffset & (~meminfo->erasesize+1);
 			offs = blockstart;
 			baderaseblock = 0;
 			/* check all the blocks in an erase block for
 			 * bad blocks */
 			do {
 				int ret = meminfo->block_isbad(meminfo, offs);
 				if (ret < 0) {
 					printf("Bad block check failed\n");
 					return -1;
 				}
 				if (ret == 1) {
 					baderaseblock = 1;
 					if (!opts->quiet)
 						printf("\rBad block at 0x%lx "
 						       "in erase block from "
 						       "0x%x will be skipped\n",
 						       (long) offs,
 						       blockstart);
 				}
 				if (baderaseblock) {
 					mtdoffset = blockstart
 						+ meminfo->erasesize;
 				}
 				offs +=	 meminfo->erasesize;
 			} while (offs < blockstart + meminfo->erasesize);
 		}
 		/* read page data to memory buffer */
 		result = meminfo->read(meminfo,
 				       mtdoffset,
 				       meminfo->oobblock,
 				       &readlen,
 				       (unsigned char *) &data_buf);
 		if (result != 0) {
 			printf("reading NAND page at offset 0x%lx failed\n",
 			       mtdoffset);
 			return -1;
 		}
 		if (imglen < readlen) {
 			readlen = imglen;
 		}
 		memcpy(buffer, data_buf, readlen);
 		buffer += readlen;
 		imglen -= readlen;
 		if (opts->readoob) {
 			result = meminfo->read_oob(meminfo,
 						   mtdoffset,
 						   meminfo->oobsize,
 						   &readlen,
 						   (unsigned char *)
 						   &oob_buf);
 			if (result != 0) {
 				printf("\nMTD readoob failure: %d\n",
 				       result);
 				return -1;
 			}
 			if (imglen < readlen) {
 				readlen = imglen;
 			}
 			memcpy(buffer, oob_buf, readlen);
 			buffer += readlen;
 			imglen -= readlen;
 		}
 		if (!opts->quiet) {
 			int percent = (int)
 				((unsigned long long)
 				 (opts->length-imglen) * 100
 				 / opts->length);
 			/* output progress message only at whole percent
 			 * steps to reduce the number of messages printed
 			 * on (slow) serial consoles
 			 */
 			if (percent != percent_complete) {
 			if (!opts->quiet)
 				printf("\rReading data from 0x%x "
 				       "-- %3d%% complete.",
 				       mtdoffset, percent);
 				percent_complete = percent;
 			}
 		}
 		mtdoffset += meminfo->oobblock;
 	}
 	if (!opts->quiet)
 		printf("\n");
 	if (imglen > 0) {
 		printf("Could not read entire image due to bad blocks\n");
 		return -1;
 	}
 	/* return happy */
 	return 0;
 }
 /******************************************************************************
  * 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 meminfo	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(nand_info_t *meminfo, int tight)
 {
 	int ret = 0;
 	int status;
 	struct nand_chip *this = meminfo->priv;
 	/* select the NAND device */
 	this->select_chip(meminfo, 0);
 	this->cmdfunc(meminfo,
 		      (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),
 		      -1, -1);
 	/* call wait ready function */
 	status = this->waitfunc(meminfo, this, FL_WRITING);
 	/* see if device thinks it succeeded */
 	if (status & 0x01) {
 		ret = -1;
 	}
 	/* de-select the NAND device */
 	this->select_chip(meminfo, -1);
 	return ret;
 }
 /**
  * nand_get_lock_status: - query current lock state from one page of NAND
  *			   flash
  *
  * @param meminfo	nand mtd instance
  * @param offset	page address to query (muss be page aligned!)
  *
  * @return		-1 in case of error
  *			>0 lock status:
  *			  bitfield with the following combinations:
  *			  NAND_LOCK_STATUS_TIGHT: page in tight state
  *			  NAND_LOCK_STATUS_LOCK:  page locked
  *			  NAND_LOCK_STATUS_UNLOCK: page unlocked
  *
  */
 int nand_get_lock_status(nand_info_t *meminfo, ulong offset)
 {
 	int ret = 0;
 	int chipnr;
 	int page;
 	struct nand_chip *this = meminfo->priv;
 	/* select the NAND device */
 	chipnr = (int)(offset >> this->chip_shift);
 	this->select_chip(meminfo, chipnr);
 	if ((offset & (meminfo->oobblock - 1)) != 0) {
 		printf ("nand_get_lock_status: "
 			"Start address must be beginning of "
 			"nand page!\n");
 		ret = -1;
 		goto out;
 	}
 	/* check the Lock Status */
 	page = (int)(offset >> this->page_shift);
 	this->cmdfunc(meminfo, NAND_CMD_LOCK_STATUS, -1, page & this->pagemask);
 	ret = this->read_byte(meminfo) & (NAND_LOCK_STATUS_TIGHT
 					  | NAND_LOCK_STATUS_LOCK
 					  | NAND_LOCK_STATUS_UNLOCK);
  out:
 	/* de-select the NAND device */
 	this->select_chip(meminfo, -1);
 	return ret;
 }
 /**
  * nand_unlock: - Unlock area of NAND pages
  *		  only one consecutive area can be unlocked at one time!
  *
  * @param meminfo	nand mtd instance
  * @param start		start byte address
  * @param length	number of bytes to unlock (must be a multiple of
  *			page size nand->oobblock)
  *
  * @return		0 on success, -1 in case of error
  */
 int nand_unlock(nand_info_t *meminfo, ulong start, ulong length)
 {
 	int ret = 0;
 	int chipnr;
 	int status;
 	int page;
 	struct nand_chip *this = meminfo->priv;
 	printf ("nand_unlock: start: %08x, length: %d!\n",
 		(int)start, (int)length);
 	/* select the NAND device */
 	chipnr = (int)(start >> this->chip_shift);
 	this->select_chip(meminfo, chipnr);
 	/* check the WP bit */
 	this->cmdfunc(meminfo, NAND_CMD_STATUS, -1, -1);
 	if ((this->read_byte(meminfo) & 0x80) == 0) {
 		printf ("nand_unlock: Device is write protected!\n");
 		ret = -1;
 		goto out;
 	}
 	if ((start & (meminfo->oobblock - 1)) != 0) {
 		printf ("nand_unlock: Start address must be beginning of "
 			"nand page!\n");
 		ret = -1;
 		goto out;
 	}
 	if (length == 0 || (length & (meminfo->oobblock - 1)) != 0) {
 		printf ("nand_unlock: Length must be a multiple of nand page "
 			"size!\n");
 		ret = -1;
 		goto out;
 	}
 	/* submit address of first page to unlock */
 	page = (int)(start >> this->page_shift);
 	this->cmdfunc(meminfo, NAND_CMD_UNLOCK1, -1, page & this->pagemask);
 	/* submit ADDRESS of LAST page to unlock */
 	page += (int)(length >> this->page_shift) - 1;
 	this->cmdfunc(meminfo, NAND_CMD_UNLOCK2, -1, page & this->pagemask);
 	/* call wait ready function */
 	status = this->waitfunc(meminfo, this, FL_WRITING);
 	/* see if device thinks it succeeded */
 	if (status & 0x01) {
 		/* there was an error */
 		ret = -1;
 		goto out;
 	}
  out:
 	/* de-select the NAND device */
 	this->select_chip(meminfo, -1);
 	return ret;
 }
 #endif /* (CONFIG_COMMANDS & CFG_CMD_NAND) && !defined(CFG_NAND_LEGACY) */

include/arm925t.h

Diff comments View file @ d983189

 /************************************************
  * NAME	    : arm925t.h
  * Version  : 23 June 2003			*
  ************************************************/
 #ifndef __ARM925T_H__
 #define __ARM925T_H__
-void gpioreserve(ushort mask);
-void gpiosetdir(ushort mask, ushort in);
-void gpiosetout(ushort mask, ushort out);
-void gpioinit(void);
 void archflashwp(void *archdata, int wp);
 #endif /*__ARM925T_H__*/

1	/*	1	/*
2	* (C) Copyright 2005 2N TELEKOMUNIKACE, Ladislav Michl	2	* (C) Copyright 2005 2N TELEKOMUNIKACE, Ladislav Michl
3	*	3	*
4	* See file CREDITS for list of people who contributed to this	4	* See file CREDITS for list of people who contributed to this
5	* project.	5	* project.
6	*	6	*
7	* This program is free software; you can redistribute it and/or	7	* This program is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU General Public License as	8	* modify it under the terms of the GNU General Public License as
9	* published by the Free Software Foundation; either version 2 of	9	* published by the Free Software Foundation; either version 2 of
10	* the License, or (at your option) any later version.	10	* the License, or (at your option) any later version.
11	*	11	*
12	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.	15	* GNU General Public License for more details.
16	*	16	*
17	* You should have received a copy of the GNU General Public License	17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software	18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA	20	* MA 02111-1307 USA
21	*/	21	*/
22		22
23	#include <common.h>	23	#include <common.h>
24		24
25	DECLARE_GLOBAL_DATA_PTR;	25	DECLARE_GLOBAL_DATA_PTR;
26		26
27	int board_init(void)	27	int board_init(void)
28	{	28	{
29	/* arch number of NetStar board */	29	/* arch number of NetStar board */
30	gd->bd->bi_arch_number = 692;	30	gd->bd->bi_arch_number = MACH_TYPE_NETSTAR;
31		31
32	/* adress of boot parameters */	32	/* adress of boot parameters */
33	gd->bd->bi_boot_params = 0x10000100;	33	gd->bd->bi_boot_params = 0x10000100;
34		34
35	return 0;	35	return 0;
36	}	36	}
37		37
38	int dram_init(void)	38	int dram_init(void)
39	{	39	{
40	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;	40	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
41	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;	41	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
42		42
43	/* Take the Ethernet controller out of reset and wait	43	/* Take the Ethernet controller out of reset and wait
44	* for the EEPROM load to complete. */	44	* for the EEPROM load to complete. */
45	((volatile unsigned short ) GPIO_DATA_OUTPUT_REG) \|= 0x80;	45	((volatile unsigned short ) GPIO_DATA_OUTPUT_REG) \|= 0x80;
46	udelay(10); /* doesn't work before interrupt_init call */	46	udelay(10); /* doesn't work before interrupt_init call */
47	((volatile unsigned short ) GPIO_DATA_OUTPUT_REG) &= ~0x80;	47	((volatile unsigned short ) GPIO_DATA_OUTPUT_REG) &= ~0x80;
48	udelay(500);	48	udelay(500);
49		49
50	return 0;	50	return 0;
51	}	51	}
52		52
53	int misc_init_r(void)	53	int misc_init_r(void)
54	{	54	{
55	return 0;	55	return 0;
56	}	56	}
57		57
58	int board_late_init(void)	58	int board_late_init(void)
59	{	59	{
60	return 0;	60	return 0;
61	}	61	}
62		62