[thirdparty/u-boot.git] / common / cmd_ubi.c

/*
 * Unsorted Block Image commands
 *
 *  Copyright (C) 2008 Samsung Electronics
 *  Kyungmin Park <kyungmin.park@samsung.com>
 *
 * Copyright 2008 Stefan Roese <sr@denx.de>, DENX Software Engineering
 *
 * 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.
 */

#include <common.h>
#include <command.h>
#include <exports.h>

#include <nand.h>
#include <onenand_uboot.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <ubi_uboot.h>
#include <asm/errno.h>
#include <jffs2/load_kernel.h>

#define DEV_TYPE_NONE		0
#define DEV_TYPE_NAND		1
#define DEV_TYPE_ONENAND	2
#define DEV_TYPE_NOR		3

/* Private own data */
static struct ubi_device *ubi;
static char buffer[80];
static int ubi_initialized;

struct selected_dev {
	char dev_name[32];	/* NAND/OneNAND etc */
	char part_name[80];
	int type;
	int nr;
	struct mtd_info *mtd_info;
};

static struct selected_dev ubi_dev;

static void ubi_dump_vol_info(const struct ubi_volume *vol)
{
	ubi_msg("volume information dump:");
	ubi_msg("vol_id          %d", vol->vol_id);
	ubi_msg("reserved_pebs   %d", vol->reserved_pebs);
	ubi_msg("alignment       %d", vol->alignment);
	ubi_msg("data_pad        %d", vol->data_pad);
	ubi_msg("vol_type        %d", vol->vol_type);
	ubi_msg("name_len        %d", vol->name_len);
	ubi_msg("usable_leb_size %d", vol->usable_leb_size);
	ubi_msg("used_ebs        %d", vol->used_ebs);
	ubi_msg("used_bytes      %lld", vol->used_bytes);
	ubi_msg("last_eb_bytes   %d", vol->last_eb_bytes);
	ubi_msg("corrupted       %d", vol->corrupted);
	ubi_msg("upd_marker      %d", vol->upd_marker);

	if (vol->name_len <= UBI_VOL_NAME_MAX &&
		strnlen(vol->name, vol->name_len + 1) == vol->name_len) {
		ubi_msg("name            %s", vol->name);
	} else {
		ubi_msg("the 1st 5 characters of the name: %c%c%c%c%c",
				vol->name[0], vol->name[1], vol->name[2],
				vol->name[3], vol->name[4]);
	}
	printf("\n");
}

static void display_volume_info(struct ubi_device *ubi)
{
	int i;

	for (i = 0; i < (ubi->vtbl_slots + 1); i++) {
		if (!ubi->volumes[i])
			continue;	/* Empty record */
		ubi_dump_vol_info(ubi->volumes[i]);
	}
}

static void display_ubi_info(struct ubi_device *ubi)
{
	ubi_msg("MTD device name:            \"%s\"", ubi->mtd->name);
	ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
	ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
			ubi->peb_size, ubi->peb_size >> 10);
	ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
	ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
	ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
	ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
	ubi_msg("VID header offset:          %d (aligned %d)",
			ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
	ubi_msg("data offset:                %d", ubi->leb_start);
	ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
	ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
	ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
	ubi_msg("number of user volumes:     %d",
			ubi->vol_count - UBI_INT_VOL_COUNT);
	ubi_msg("available PEBs:             %d", ubi->avail_pebs);
	ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
	ubi_msg("number of PEBs reserved for bad PEB handling: %d",
			ubi->beb_rsvd_pebs);
	ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
}

static int ubi_info(int layout)
{
	if (layout)
		display_volume_info(ubi);
	else
		display_ubi_info(ubi);

	return 0;
}

static int verify_mkvol_req(const struct ubi_device *ubi,
			    const struct ubi_mkvol_req *req)
{
	int n, err = -EINVAL;

	if (req->bytes < 0 || req->alignment < 0 || req->vol_type < 0 ||
	    req->name_len < 0)
		goto bad;

	if ((req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) &&
	    req->vol_id != UBI_VOL_NUM_AUTO)
		goto bad;

	if (req->alignment == 0)
		goto bad;

	if (req->bytes == 0)
		goto bad;

	if (req->vol_type != UBI_DYNAMIC_VOLUME &&
	    req->vol_type != UBI_STATIC_VOLUME)
		goto bad;

	if (req->alignment > ubi->leb_size)
		goto bad;

	n = req->alignment % ubi->min_io_size;
	if (req->alignment != 1 && n)
		goto bad;

	if (req->name_len > UBI_VOL_NAME_MAX) {
		err = -ENAMETOOLONG;
		goto bad;
	}

	return 0;
bad:
	printf("bad volume creation request");
	return err;
}

static int ubi_create_vol(char *volume, int size, int dynamic)
{
	struct ubi_mkvol_req req;
	int err;

	if (dynamic)
		req.vol_type = UBI_DYNAMIC_VOLUME;
	else
		req.vol_type = UBI_STATIC_VOLUME;

	req.vol_id = UBI_VOL_NUM_AUTO;
	req.alignment = 1;
	req.bytes = size;

	strcpy(req.name, volume);
	req.name_len = strlen(volume);
	req.name[req.name_len] = '\0';
	req.padding1 = 0;
	/* It's duplicated at drivers/mtd/ubi/cdev.c */
	err = verify_mkvol_req(ubi, &req);
	if (err) {
		printf("verify_mkvol_req failed %d\n", err);
		return err;
	}
	printf("Creating %s volume %s of size %d\n",
		dynamic ? "dynamic" : "static", volume, size);
	/* Call real ubi create volume */
	return ubi_create_volume(ubi, &req);
}

static int ubi_remove_vol(char *volume)
{
	int i, err, reserved_pebs;
	int found = 0, vol_id = 0;
	struct ubi_volume *vol;

	for (i = 0; i < ubi->vtbl_slots; i++) {
		vol = ubi->volumes[i];
		if (vol && !strcmp(vol->name, volume)) {
			printf("Volume %s found at valid %d\n", volume, i);
			vol_id = i;
			found = 1;
			break;
		}
	}
	if (!found) {
		printf("%s volume not found\n", volume);
		return -ENODEV;
	}
	printf("remove UBI volume %s (id %d)\n", vol->name, vol->vol_id);

	if (ubi->ro_mode) {
		printf("It's read-only mode\n");
		err = -EROFS;
		goto out_err;
	}

	err = ubi_change_vtbl_record(ubi, vol_id, NULL);
	if (err) {
		printf("Error changing Vol tabel record err=%x\n", err);
		goto out_err;
	}
	reserved_pebs = vol->reserved_pebs;
	for (i = 0; i < vol->reserved_pebs; i++) {
		err = ubi_eba_unmap_leb(ubi, vol, i);
		if (err)
			goto out_err;
	}

	kfree(vol->eba_tbl);
	ubi->volumes[vol_id]->eba_tbl = NULL;
	ubi->volumes[vol_id] = NULL;

	ubi->rsvd_pebs -= reserved_pebs;
	ubi->avail_pebs += reserved_pebs;
	i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
	if (i > 0) {
		i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
		ubi->avail_pebs -= i;
		ubi->rsvd_pebs += i;
		ubi->beb_rsvd_pebs += i;
		if (i > 0)
			ubi_msg("reserve more %d PEBs", i);
	}
	ubi->vol_count -= 1;

	return 0;
out_err:
	ubi_err("cannot remove volume %d, error %d", vol_id, err);
	return err;
}

static int ubi_volume_write(char *volume, void *buf, size_t size)
{
	int i = 0, err = -1;
	int rsvd_bytes = 0;
	int found = 0;
	struct ubi_volume *vol;

	for (i = 0; i < ubi->vtbl_slots; i++) {
		vol = ubi->volumes[i];
		if (vol && !strcmp(vol->name, volume)) {
			printf("Volume \"%s\" found at volume id %d\n", volume, i);
			found = 1;
			break;
		}
	}
	if (!found) {
		printf("%s volume not found\n", volume);
		return 1;
	}
	rsvd_bytes = vol->reserved_pebs * (ubi->leb_size - vol->data_pad);
	if (size < 0 || size > rsvd_bytes) {
		printf("rsvd_bytes=%d vol->reserved_pebs=%d ubi->leb_size=%d\n",
		     rsvd_bytes, vol->reserved_pebs, ubi->leb_size);
		printf("vol->data_pad=%d\n", vol->data_pad);
		printf("Size > volume size !!\n");
		return 1;
	}

	err = ubi_start_update(ubi, vol, size);
	if (err < 0) {
		printf("Cannot start volume update\n");
		return err;
	}

	err = ubi_more_update_data(ubi, vol, buf, size);
	if (err < 0) {
		printf("Couldnt or partially wrote data \n");
		return err;
	}

	if (err) {
		size = err;

		err = ubi_check_volume(ubi, vol->vol_id);
		if ( err < 0 )
			return err;

		if (err) {
			ubi_warn("volume %d on UBI device %d is corrupted",
					vol->vol_id, ubi->ubi_num);
			vol->corrupted = 1;
		}

		vol->checked = 1;
		ubi_gluebi_updated(vol);
	}

	return 0;
}

static int ubi_volume_read(char *volume, char *buf, size_t size)
{
	int err, lnum, off, len, tbuf_size, i = 0;
	size_t count_save = size;
	void *tbuf;
	unsigned long long tmp;
	struct ubi_volume *vol = NULL;
	loff_t offp = 0;

	for (i = 0; i < ubi->vtbl_slots; i++) {
		vol = ubi->volumes[i];
		if (vol && !strcmp(vol->name, volume)) {
			printf("Volume %s found at volume id %d\n",
				volume, vol->vol_id);
			break;
		}
	}
	if (i == ubi->vtbl_slots) {
		printf("%s volume not found\n", volume);
		return 0;
	}

	printf("read %i bytes from volume %d to %x(buf address)\n",
	       (int) size, vol->vol_id, (unsigned)buf);

	if (vol->updating) {
		printf("updating");
		return -EBUSY;
	}
	if (vol->upd_marker) {
		printf("damaged volume, update marker is set");
		return -EBADF;
	}
	if (offp == vol->used_bytes)
		return 0;

	if (size == 0) {
		printf("Read [%lu] bytes\n", (unsigned long) vol->used_bytes);
		size = vol->used_bytes;
	}

	if (vol->corrupted)
		printf("read from corrupted volume %d", vol->vol_id);
	if (offp + size > vol->used_bytes)
		count_save = size = vol->used_bytes - offp;

	tbuf_size = vol->usable_leb_size;
	if (size < tbuf_size)
		tbuf_size = ALIGN(size, ubi->min_io_size);
	tbuf = malloc(tbuf_size);
	if (!tbuf) {
		printf("NO MEM\n");
		return -ENOMEM;
	}
	len = size > tbuf_size ? tbuf_size : size;

	tmp = offp;
	off = do_div(tmp, vol->usable_leb_size);
	lnum = tmp;
	do {
		if (off + len >= vol->usable_leb_size)
			len = vol->usable_leb_size - off;

		err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0);
		if (err) {
			printf("read err %x\n", err);
			break;
		}
		off += len;
		if (off == vol->usable_leb_size) {
			lnum += 1;
			off -= vol->usable_leb_size;
		}

		size -= len;
		offp += len;

		memcpy(buf, tbuf, len);

		buf += len;
		len = size > tbuf_size ? tbuf_size : size;
	} while (size);

	free(tbuf);
	return err ? err : count_save - size;
}

static int ubi_dev_scan(struct mtd_info *info, char *ubidev)
{
	struct mtd_device *dev;
	struct part_info *part;
	struct mtd_partition mtd_part;
	u8 pnum;
	int err;

	if (find_dev_and_part(ubidev, &dev, &pnum, &part) != 0)
		return 1;

	sprintf(buffer, "mtd=%d", pnum);
	memset(&mtd_part, 0, sizeof(mtd_part));
	mtd_part.name = buffer;
	mtd_part.size = part->size;
	mtd_part.offset = part->offset;
	add_mtd_partitions(info, &mtd_part, 1);

	err = ubi_mtd_param_parse(buffer, NULL);
	if (err) {
		del_mtd_partitions(info);
		return err;
	}

	err = ubi_init();
	if (err) {
		del_mtd_partitions(info);
		return err;
	}

	ubi_initialized = 1;

	return 0;
}

static int do_ubi(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
	size_t size = 0;
	ulong addr = 0;
	int err = 0;

	if (argc < 2) {
		cmd_usage(cmdtp);
		return 1;
	}

	if (mtdparts_init() != 0) {
		printf("Error initializing mtdparts!\n");
		return 1;
	}

	if (strcmp(argv[1], "part") == 0) {
		/* Print current partition */
		if (argc == 2) {
			if (ubi_dev.type == DEV_TYPE_NONE) {
				printf("Error, no UBI device/partition selected!\n");
				return 1;
			}

			printf("%s Device %d: %s, partition %s\n", ubi_dev.dev_name,
			       ubi_dev.nr, ubi_dev.mtd_info->name, ubi_dev.part_name);
			return 0;
		}

		if (argc < 4) {
			cmd_usage(cmdtp);
			return 1;
		}

		/* todo: get dev number for NAND... */
		ubi_dev.nr = 0;

		/*
		 * Call ubi_exit() before re-initializing the UBI subsystem
		 */
		if (ubi_initialized) {
			ubi_exit();
			del_mtd_partitions(ubi_dev.mtd_info);
		}

		/*
		 * Check for nor|nand|onenand selection
		 */
#if defined(CONFIG_CMD_NAND)
		if (strcmp(argv[2], "nand") == 0) {
			strcpy(ubi_dev.dev_name, "NAND");
			ubi_dev.type = DEV_TYPE_NAND;
			ubi_dev.mtd_info = &nand_info[ubi_dev.nr];
		}
#endif
#if defined(CONFIG_FLASH_CFI_MTD)
		if (strcmp(argv[2], "nor") == 0) {
			char mtd_dev[16];
			struct mtd_device *dev;
			struct part_info *part;
			u8 pnum;

			/*
			 * Search the mtd device number where this partition
			 * is located
			 */
			if (find_dev_and_part(argv[3], &dev, &pnum, &part)) {
				printf("Partition %s not found!\n", argv[3]);
				return 1;
			}
			sprintf(mtd_dev, "nor%d", dev->id->num);
			ubi_dev.mtd_info = get_mtd_device_nm(mtd_dev);
			strcpy(ubi_dev.dev_name, "NOR");
			ubi_dev.type = DEV_TYPE_NOR;
		}
#endif
#if defined(CONFIG_CMD_ONENAND)
		if (strcmp(argv[2], "onenand") == 0) {
			strcpy(ubi_dev.dev_name, "OneNAND");
			ubi_dev.type = DEV_TYPE_ONENAND;
			ubi_dev.mtd_info = &onenand_mtd;
		}
#endif

		if (ubi_dev.type == DEV_TYPE_NONE) {
			printf("Error, no UBI device/partition selected!\n");
			return 1;
		}

		strcpy(ubi_dev.part_name, argv[3]);
		err = ubi_dev_scan(ubi_dev.mtd_info, ubi_dev.part_name);
		if (err) {
			printf("UBI init error %d\n", err);
			ubi_dev.type = DEV_TYPE_NONE;
			return err;
		}

		ubi = ubi_devices[0];

		return 0;
	}

	if ((strcmp(argv[1], "part") != 0) && (ubi_dev.type == DEV_TYPE_NONE)) {
		printf("Error, no UBI device/partition selected!\n");
		return 1;
	}

	if (strcmp(argv[1], "info") == 0) {
		int layout = 0;
		if (argc > 2 && !strncmp(argv[2], "l", 1))
			layout = 1;
		return ubi_info(layout);
	}

	if (strncmp(argv[1], "create", 6) == 0) {
		int dynamic = 1;	/* default: dynamic volume */

		/* Use maximum available size */
		size = 0;

		/* E.g., create volume size type */
		if (argc == 5) {
			if (strncmp(argv[4], "s", 1) == 0)
				dynamic = 0;
			else if (strncmp(argv[4], "d", 1) != 0) {
				printf("Incorrect type\n");
				return 1;
			}
			argc--;
		}
		/* E.g., create volume size */
		if (argc == 4) {
			size = simple_strtoul(argv[3], NULL, 16);
			argc--;
		}
		/* Use maximum available size */
		if (!size)
			size = ubi->avail_pebs * ubi->leb_size;
		/* E.g., create volume */
		if (argc == 3)
			return ubi_create_vol(argv[2], size, dynamic);
	}

	if (strncmp(argv[1], "remove", 6) == 0) {
		/* E.g., remove volume */
		if (argc == 3)
			return ubi_remove_vol(argv[2]);
	}

	if (strncmp(argv[1], "write", 5) == 0) {
		if (argc < 5) {
			printf("Please see usage\n");
			return 1;
		}

		addr = simple_strtoul(argv[2], NULL, 16);
		size = simple_strtoul(argv[4], NULL, 16);

		return ubi_volume_write(argv[3], (void *)addr, size);
	}

	if (strncmp(argv[1], "read", 4) == 0) {
		size = 0;

		/* E.g., read volume size */
		if (argc == 5) {
			size = simple_strtoul(argv[4], NULL, 16);
			argc--;
		}

		/* E.g., read volume */
		if (argc == 4) {
			addr = simple_strtoul(argv[2], NULL, 16);
			argc--;
		}

		if (argc == 3)
			return ubi_volume_read(argv[3], (char *)addr, size);
	}

	printf("Please see usage\n");
	return -1;
}

U_BOOT_CMD(ubi, 6, 1, do_ubi,
	"ubi commands",
	"part [nand|nor|onenand] [part]"
		" - Show or set current partition\n"
	"ubi info [l[ayout]]"
		" - Display volume and ubi layout information\n"
	"ubi create[vol] volume [size] [type]"
		" - create volume name with size\n"
	"ubi write[vol] address volume size"
		" - Write volume from address with size\n"
	"ubi read[vol] address volume [size]"
		" - Read volume to address with size\n"
	"ubi remove[vol] volume"
		" - Remove volume\n"
	"[Legends]\n"
	" volume: charater name\n"
	" size: KiB, MiB, GiB, and bytes\n"
	" type: s[tatic] or d[ynamic] (default=dynamic)\n"
);
Commit	Line	Data
694a0b3f KP	1	/*
	2	* Unsorted Block Image commands
	3	*
	4	* Copyright (C) 2008 Samsung Electronics
	5	* Kyungmin Park <kyungmin.park@samsung.com>
	6	*
	7	* Copyright 2008 Stefan Roese <sr@denx.de>, DENX Software Engineering
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
	14	#include <common.h>
	15	#include <command.h>
	16	#include <exports.h>
	17
	18	#include <nand.h>
	19	#include <onenand_uboot.h>
	20	#include <linux/mtd/mtd.h>
	21	#include <linux/mtd/partitions.h>
	22	#include <ubi_uboot.h>
	23	#include <asm/errno.h>
	24	#include <jffs2/load_kernel.h>
	25
	26	#define DEV_TYPE_NONE 0
	27	#define DEV_TYPE_NAND 1
	28	#define DEV_TYPE_ONENAND 2
25ea652e	29	#define DEV_TYPE_NOR 3
694a0b3f KP	30
	31	/* Private own data */
	32	static struct ubi_device *ubi;
a5c40670	33	static char buffer[80];
2ee951ba	34	static int ubi_initialized;
694a0b3f KP	35
	36	struct selected_dev {
	37	char dev_name[32]; /* NAND/OneNAND etc */
	38	char part_name[80];
	39	int type;
	40	int nr;
	41	struct mtd_info *mtd_info;
	42	};
	43
	44	static struct selected_dev ubi_dev;
	45
	46	static void ubi_dump_vol_info(const struct ubi_volume *vol)
	47	{
	48	ubi_msg("volume information dump:");
	49	ubi_msg("vol_id %d", vol->vol_id);
	50	ubi_msg("reserved_pebs %d", vol->reserved_pebs);
	51	ubi_msg("alignment %d", vol->alignment);
	52	ubi_msg("data_pad %d", vol->data_pad);
	53	ubi_msg("vol_type %d", vol->vol_type);
	54	ubi_msg("name_len %d", vol->name_len);
	55	ubi_msg("usable_leb_size %d", vol->usable_leb_size);
	56	ubi_msg("used_ebs %d", vol->used_ebs);
	57	ubi_msg("used_bytes %lld", vol->used_bytes);
	58	ubi_msg("last_eb_bytes %d", vol->last_eb_bytes);
	59	ubi_msg("corrupted %d", vol->corrupted);
	60	ubi_msg("upd_marker %d", vol->upd_marker);
	61
	62	if (vol->name_len <= UBI_VOL_NAME_MAX &&
	63	strnlen(vol->name, vol->name_len + 1) == vol->name_len) {
	64	ubi_msg("name %s", vol->name);
	65	} else {
	66	ubi_msg("the 1st 5 characters of the name: %c%c%c%c%c",
	67	vol->name[0], vol->name[1], vol->name[2],
	68	vol->name[3], vol->name[4]);
	69	}
	70	printf("\n");
	71	}
	72
	73	static void display_volume_info(struct ubi_device *ubi)
	74	{
	75	int i;
	76
	77	for (i = 0; i < (ubi->vtbl_slots + 1); i++) {
	78	if (!ubi->volumes[i])
	79	continue; /* Empty record */
	80	ubi_dump_vol_info(ubi->volumes[i]);
	81	}
	82	}
	83
	84	static void display_ubi_info(struct ubi_device *ubi)
	85	{
	86	ubi_msg("MTD device name: \"%s\"", ubi->mtd->name);
	87	ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20);
	88	ubi_msg("physical eraseblock size: %d bytes (%d KiB)",
	89	ubi->peb_size, ubi->peb_size >> 10);
	90	ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size);
	91	ubi_msg("number of good PEBs: %d", ubi->good_peb_count);
	92	ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count);
	93	ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size);
	94	ubi_msg("VID header offset: %d (aligned %d)",
	95	ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
	96	ubi_msg("data offset: %d", ubi->leb_start);
	97	ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots);
	98	ubi_msg("wear-leveling threshold: %d", CONFIG_MTD_UBI_WL_THRESHOLD);
99	ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
100	ubi_msg("number of user volumes: %d",
101	ubi->vol_count - UBI_INT_VOL_COUNT);
102	ubi_msg("available PEBs: %d", ubi->avail_pebs);
103	ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
104	ubi_msg("number of PEBs reserved for bad PEB handling: %d",
105	ubi->beb_rsvd_pebs);
106	ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
107	}
108
109	static int ubi_info(int layout)
110	{
111	if (layout)
112	display_volume_info(ubi);
113	else
114	display_ubi_info(ubi);
115
116	return 0;
117	}
118
694a0b3f KP	119	static int verify_mkvol_req(const struct ubi_device *ubi,
	120	const struct ubi_mkvol_req *req)
	121	{
	122	int n, err = -EINVAL;
	123
	124	if (req->bytes < 0 \|\| req->alignment < 0 \|\| req->vol_type < 0 \|\|
	125	req->name_len < 0)
	126	goto bad;
	127
	128	if ((req->vol_id < 0 \|\| req->vol_id >= ubi->vtbl_slots) &&
	129	req->vol_id != UBI_VOL_NUM_AUTO)
	130	goto bad;
	131
	132	if (req->alignment == 0)
	133	goto bad;
	134
	135	if (req->bytes == 0)
	136	goto bad;
	137
	138	if (req->vol_type != UBI_DYNAMIC_VOLUME &&
	139	req->vol_type != UBI_STATIC_VOLUME)
	140	goto bad;
	141
	142	if (req->alignment > ubi->leb_size)
	143	goto bad;
	144
	145	n = req->alignment % ubi->min_io_size;
	146	if (req->alignment != 1 && n)
	147	goto bad;
	148
	149	if (req->name_len > UBI_VOL_NAME_MAX) {
	150	err = -ENAMETOOLONG;
	151	goto bad;
	152	}
	153
	154	return 0;
	155	bad:
	156	printf("bad volume creation request");
	157	return err;
	158	}
	159
	160	static int ubi_create_vol(char *volume, int size, int dynamic)
	161	{
	162	struct ubi_mkvol_req req;
	163	int err;
	164
	165	if (dynamic)
	166	req.vol_type = UBI_DYNAMIC_VOLUME;
	167	else
	168	req.vol_type = UBI_STATIC_VOLUME;
	169
	170	req.vol_id = UBI_VOL_NUM_AUTO;
	171	req.alignment = 1;
	172	req.bytes = size;
	173
	174	strcpy(req.name, volume);
	175	req.name_len = strlen(volume);
	176	req.name[req.name_len] = '\0';
	177	req.padding1 = 0;
	178	/* It's duplicated at drivers/mtd/ubi/cdev.c */
	179	err = verify_mkvol_req(ubi, &req);
	180	if (err) {
	181	printf("verify_mkvol_req failed %d\n", err);
	182	return err;
183	}
184	printf("Creating %s volume %s of size %d\n",
185	dynamic ? "dynamic" : "static", volume, size);
186	/* Call real ubi create volume */
187	return ubi_create_volume(ubi, &req);
188	}
189
190	static int ubi_remove_vol(char *volume)
191	{
192	int i, err, reserved_pebs;
193	int found = 0, vol_id = 0;
194	struct ubi_volume *vol;
195
196	for (i = 0; i < ubi->vtbl_slots; i++) {
197	vol = ubi->volumes[i];
198	if (vol && !strcmp(vol->name, volume)) {
199	printf("Volume %s found at valid %d\n", volume, i);
200	vol_id = i;
201	found = 1;
202	break;
203	}
204	}
205	if (!found) {
206	printf("%s volume not found\n", volume);
207	return -ENODEV;
208	}
209	printf("remove UBI volume %s (id %d)\n", vol->name, vol->vol_id);
210
211	if (ubi->ro_mode) {
212	printf("It's read-only mode\n");
213	err = -EROFS;
214	goto out_err;
215	}
216
217	err = ubi_change_vtbl_record(ubi, vol_id, NULL);
218	if (err) {
219	printf("Error changing Vol tabel record err=%x\n", err);
220	goto out_err;
221	}
222	reserved_pebs = vol->reserved_pebs;
223	for (i = 0; i < vol->reserved_pebs; i++) {
224	err = ubi_eba_unmap_leb(ubi, vol, i);
225	if (err)
226	goto out_err;
227	}
228
229	kfree(vol->eba_tbl);
230	ubi->volumes[vol_id]->eba_tbl = NULL;
231	ubi->volumes[vol_id] = NULL;
232
233	ubi->rsvd_pebs -= reserved_pebs;
234	ubi->avail_pebs += reserved_pebs;
235	i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
236	if (i > 0) {
237	i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
238	ubi->avail_pebs -= i;
239	ubi->rsvd_pebs += i;
240	ubi->beb_rsvd_pebs += i;
241	if (i > 0)
242	ubi_msg("reserve more %d PEBs", i);
243	}
244	ubi->vol_count -= 1;
245
246	return 0;
247	out_err:
248	ubi_err("cannot remove volume %d, error %d", vol_id, err);
249	return err;
250	}
251
252	static int ubi_volume_write(char volume, void buf, size_t size)
253	{
254	int i = 0, err = -1;
255	int rsvd_bytes = 0;
256	int found = 0;
257	struct ubi_volume *vol;
258
259	for (i = 0; i < ubi->vtbl_slots; i++) {
260	vol = ubi->volumes[i];
261	if (vol && !strcmp(vol->name, volume)) {
262	printf("Volume \"%s\" found at volume id %d\n", volume, i);
263	found = 1;
264	break;
265	}
266	}
267	if (!found) {
268	printf("%s volume not found\n", volume);
269	return 1;
270	}
271	rsvd_bytes = vol->reserved_pebs * (ubi->leb_size - vol->data_pad);
272	if (size < 0 \|\| size > rsvd_bytes) {
273	printf("rsvd_bytes=%d vol->reserved_pebs=%d ubi->leb_size=%d\n",
274	rsvd_bytes, vol->reserved_pebs, ubi->leb_size);
275	printf("vol->data_pad=%d\n", vol->data_pad);
276	printf("Size > volume size !!\n");
277	return 1;
278	}
279
280	err = ubi_start_update(ubi, vol, size);
281	if (err < 0) {
282	printf("Cannot start volume update\n");
283	return err;
284	}
285
286	err = ubi_more_update_data(ubi, vol, buf, size);
287	if (err < 0) {
288	printf("Couldnt or partially wrote data \n");
289	return err;
290	}
291
292	if (err) {
293	size = err;
294
295	err = ubi_check_volume(ubi, vol->vol_id);
296	if ( err < 0 )
297	return err;
298
299	if (err) {
300	ubi_warn("volume %d on UBI device %d is corrupted",
301	vol->vol_id, ubi->ubi_num);
302	vol->corrupted = 1;
303	}
304
305	vol->checked = 1;
306	ubi_gluebi_updated(vol);
307	}
308
309	return 0;
310	}
311
312	static int ubi_volume_read(char volume, char buf, size_t size)
313	{
314	int err, lnum, off, len, tbuf_size, i = 0;
315	size_t count_save = size;
316	void *tbuf;
317	unsigned long long tmp;
318	struct ubi_volume *vol = NULL;
319	loff_t offp = 0;
320
321	for (i = 0; i < ubi->vtbl_slots; i++) {
322	vol = ubi->volumes[i];
323	if (vol && !strcmp(vol->name, volume)) {
324	printf("Volume %s found at volume id %d\n",
325	volume, vol->vol_id);
326	break;
327	}
328	}
329	if (i == ubi->vtbl_slots) {
330	printf("%s volume not found\n", volume);
331	return 0;
332	}
333
334	printf("read %i bytes from volume %d to %x(buf address)\n",
335	(int) size, vol->vol_id, (unsigned)buf);
336
337	if (vol->updating) {
338	printf("updating");
339	return -EBUSY;
340	}
341	if (vol->upd_marker) {
342	printf("damaged volume, update marker is set");
343	return -EBADF;
344	}
345	if (offp == vol->used_bytes)
346	return 0;
347
348	if (size == 0) {
349	printf("Read [%lu] bytes\n", (unsigned long) vol->used_bytes);
350	size = vol->used_bytes;
351	}
352
353	if (vol->corrupted)
354	printf("read from corrupted volume %d", vol->vol_id);
355	if (offp + size > vol->used_bytes)
356	count_save = size = vol->used_bytes - offp;
357
358	tbuf_size = vol->usable_leb_size;
359	if (size < tbuf_size)
360	tbuf_size = ALIGN(size, ubi->min_io_size);
361	tbuf = malloc(tbuf_size);
362	if (!tbuf) {
363	printf("NO MEM\n");
364	return -ENOMEM;
365	}
366	len = size > tbuf_size ? tbuf_size : size;
367
368	tmp = offp;
369	off = do_div(tmp, vol->usable_leb_size);
370	lnum = tmp;
694a0b3f KP	371	do {
	372	if (off + len >= vol->usable_leb_size)
	373	len = vol->usable_leb_size - off;
	374
	375	err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0);
	376	if (err) {
	377	printf("read err %x\n", err);
	378	break;
	379	}
	380	off += len;
	381	if (off == vol->usable_leb_size) {
	382	lnum += 1;
	383	off -= vol->usable_leb_size;
	384	}
	385
	386	size -= len;
	387	offp += len;
	388
694a0b3f	389	memcpy(buf, tbuf, len);
694a0b3f KP	390
	391	buf += len;
	392	len = size > tbuf_size ? tbuf_size : size;
	393	} while (size);
	394
	395	free(tbuf);
	396	return err ? err : count_save - size;
	397	}
	398
	399	static int ubi_dev_scan(struct mtd_info info, char ubidev)
	400	{
	401	struct mtd_device *dev;
	402	struct part_info *part;
	403	struct mtd_partition mtd_part;
694a0b3f KP	404	u8 pnum;
	405	int err;
	406
694a0b3f KP	407	if (find_dev_and_part(ubidev, &dev, &pnum, &part) != 0)
	408	return 1;
	409
	410	sprintf(buffer, "mtd=%d", pnum);
	411	memset(&mtd_part, 0, sizeof(mtd_part));
	412	mtd_part.name = buffer;
	413	mtd_part.size = part->size;
	414	mtd_part.offset = part->offset;
	415	add_mtd_partitions(info, &mtd_part, 1);
	416
	417	err = ubi_mtd_param_parse(buffer, NULL);
	418	if (err) {
	419	del_mtd_partitions(info);
	420	return err;
	421	}
	422
	423	err = ubi_init();
	424	if (err) {
	425	del_mtd_partitions(info);
	426	return err;
	427	}
	428
2ee951ba SR	429	ubi_initialized = 1;
2ee951ba SR	430
694a0b3f KP	431	return 0;
	432	}
	433
	434	static int do_ubi(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
	435	{
	436	size_t size = 0;
	437	ulong addr = 0;
	438	int err = 0;
	439
	440	if (argc < 2) {
62c3ae7c	441	cmd_usage(cmdtp);
694a0b3f KP	442	return 1;
	443	}
	444
c203ef5d AH	445	if (mtdparts_init() != 0) {
	446	printf("Error initializing mtdparts!\n");
	447	return 1;
	448	}
	449
694a0b3f KP	450	if (strcmp(argv[1], "part") == 0) {
	451	/* Print current partition */
	452	if (argc == 2) {
	453	if (ubi_dev.type == DEV_TYPE_NONE) {
	454	printf("Error, no UBI device/partition selected!\n");
	455	return 1;
	456	}
	457
	458	printf("%s Device %d: %s, partition %s\n", ubi_dev.dev_name,
	459	ubi_dev.nr, ubi_dev.mtd_info->name, ubi_dev.part_name);
	460	return 0;
	461	}
	462
	463	if (argc < 4) {
62c3ae7c	464	cmd_usage(cmdtp);
694a0b3f KP	465	return 1;
	466	}
	467
	468	/* todo: get dev number for NAND... */
	469	ubi_dev.nr = 0;
	470
2ee951ba SR	471	/*
	472	* Call ubi_exit() before re-initializing the UBI subsystem
	473	*/
	474	if (ubi_initialized) {
	475	ubi_exit();
	476	del_mtd_partitions(ubi_dev.mtd_info);
	477	}
	478
694a0b3f	479	/*
c203ef5d	480	* Check for nor\|nand\|onenand selection
694a0b3f KP	481	*/
	482	#if defined(CONFIG_CMD_NAND)
	483	if (strcmp(argv[2], "nand") == 0) {
	484	strcpy(ubi_dev.dev_name, "NAND");
	485	ubi_dev.type = DEV_TYPE_NAND;
	486	ubi_dev.mtd_info = &nand_info[ubi_dev.nr];
	487	}
	488	#endif
25ea652e PZ	489	#if defined(CONFIG_FLASH_CFI_MTD)
25ea652e PZ	490	if (strcmp(argv[2], "nor") == 0) {
c203ef5d AH	491	char mtd_dev[16];
	492	struct mtd_device *dev;
	493	struct part_info *part;
	494	u8 pnum;
	495
	496	/*
	497	* Search the mtd device number where this partition
	498	* is located
	499	*/
	500	if (find_dev_and_part(argv[3], &dev, &pnum, &part)) {
	501	printf("Partition %s not found!\n", argv[3]);
	502	return 1;
	503	}
	504	sprintf(mtd_dev, "nor%d", dev->id->num);
	505	ubi_dev.mtd_info = get_mtd_device_nm(mtd_dev);
25ea652e PZ	506	strcpy(ubi_dev.dev_name, "NOR");
25ea652e PZ	507	ubi_dev.type = DEV_TYPE_NOR;
25ea652e PZ	508	}
25ea652e PZ	509	#endif
694a0b3f KP	510	#if defined(CONFIG_CMD_ONENAND)
	511	if (strcmp(argv[2], "onenand") == 0) {
	512	strcpy(ubi_dev.dev_name, "OneNAND");
	513	ubi_dev.type = DEV_TYPE_ONENAND;
	514	ubi_dev.mtd_info = &onenand_mtd;
	515	}
	516	#endif
	517
	518	if (ubi_dev.type == DEV_TYPE_NONE) {
	519	printf("Error, no UBI device/partition selected!\n");
	520	return 1;
	521	}
	522
	523	strcpy(ubi_dev.part_name, argv[3]);
	524	err = ubi_dev_scan(ubi_dev.mtd_info, ubi_dev.part_name);
	525	if (err) {
	526	printf("UBI init error %d\n", err);
3b089e4f	527	ubi_dev.type = DEV_TYPE_NONE;
694a0b3f KP	528	return err;
	529	}
	530
	531	ubi = ubi_devices[0];
	532
	533	return 0;
	534	}
	535
	536	if ((strcmp(argv[1], "part") != 0) && (ubi_dev.type == DEV_TYPE_NONE)) {
	537	printf("Error, no UBI device/partition selected!\n");
	538	return 1;
	539	}
	540
	541	if (strcmp(argv[1], "info") == 0) {
	542	int layout = 0;
	543	if (argc > 2 && !strncmp(argv[2], "l", 1))
	544	layout = 1;
	545	return ubi_info(layout);
	546	}
	547
	548	if (strncmp(argv[1], "create", 6) == 0) {
	549	int dynamic = 1; /* default: dynamic volume */
	550
	551	/* Use maximum available size */
	552	size = 0;
	553
	554	/* E.g., create volume size type */
	555	if (argc == 5) {
	556	if (strncmp(argv[4], "s", 1) == 0)
	557	dynamic = 0;
	558	else if (strncmp(argv[4], "d", 1) != 0) {
	559	printf("Incorrect type\n");
	560	return 1;
	561	}
	562	argc--;
	563	}
	564	/* E.g., create volume size */
	565	if (argc == 4) {
2d2e0572	566	size = simple_strtoul(argv[3], NULL, 16);
694a0b3f KP	567	argc--;
	568	}
	569	/* Use maximum available size */
	570	if (!size)
	571	size = ubi->avail_pebs * ubi->leb_size;
	572	/* E.g., create volume */
	573	if (argc == 3)
	574	return ubi_create_vol(argv[2], size, dynamic);
	575	}
	576
	577	if (strncmp(argv[1], "remove", 6) == 0) {
	578	/* E.g., remove volume */
	579	if (argc == 3)
	580	return ubi_remove_vol(argv[2]);
	581	}
	582
	583	if (strncmp(argv[1], "write", 5) == 0) {
	584	if (argc < 5) {
	585	printf("Please see usage\n");
	586	return 1;
	587	}
	588
	589	addr = simple_strtoul(argv[2], NULL, 16);
a5c40670	590	size = simple_strtoul(argv[4], NULL, 16);
694a0b3f KP	591
	592	return ubi_volume_write(argv[3], (void *)addr, size);
	593	}
	594
	595	if (strncmp(argv[1], "read", 4) == 0) {
	596	size = 0;
	597
	598	/* E.g., read volume size */
	599	if (argc == 5) {
a5c40670	600	size = simple_strtoul(argv[4], NULL, 16);
694a0b3f KP	601	argc--;
	602	}
	603
	604	/* E.g., read volume */
	605	if (argc == 4) {
	606	addr = simple_strtoul(argv[2], NULL, 16);
	607	argc--;
	608	}
	609
	610	if (argc == 3)
	611	return ubi_volume_read(argv[3], (char *)addr, size);
	612	}
	613
	614	printf("Please see usage\n");
	615	return -1;
	616	}
	617
	618	U_BOOT_CMD(ubi, 6, 1, do_ubi,
2fb2604d	619	"ubi commands",
455ae7e8	620	"part [nand\|nor\|onenand] [part]"
694a0b3f KP	621	" - Show or set current partition\n"
	622	"ubi info [l[ayout]]"
	623	" - Display volume and ubi layout information\n"
	624	"ubi create[vol] volume [size] [type]"
	625	" - create volume name with size\n"
	626	"ubi write[vol] address volume size"
	627	" - Write volume from address with size\n"
	628	"ubi read[vol] address volume [size]"
	629	" - Read volume to address with size\n"
	630	"ubi remove[vol] volume"
	631	" - Remove volume\n"
	632	"[Legends]\n"
	633	" volume: charater name\n"
	634	" size: KiB, MiB, GiB, and bytes\n"
	635	" type: s[tatic] or d[ynamic] (default=dynamic)\n"
	636	);