[people/ms/u-boot.git] / cmd / ubi.c

/*
 * Unsorted Block Image commands
 *
 *  Copyright (C) 2008 Samsung Electronics
 *  Kyungmin Park <kyungmin.park@samsung.com>
 *
 * Copyright 2008-2009 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 <memalign.h>
#include <nand.h>
#include <onenand_uboot.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/err.h>
#include <ubi_uboot.h>
#include <asm/errno.h>
#include <jffs2/load_kernel.h>

#undef ubi_msg
#define ubi_msg(fmt, ...) printf("UBI: " fmt "\n", ##__VA_ARGS__)

#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 part_name[80];
	int selected;
	int nr;
	struct mtd_info *mtd_info;
};

static struct selected_dev ubi_dev;

#ifdef CONFIG_CMD_UBIFS
int ubifs_is_mounted(void);
void cmd_ubifs_umount(void);
#endif

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 ubi_check_volumename(const struct ubi_volume *vol, char *name)
{
	return strcmp(vol->name, name);
}

static int ubi_check(char *name)
{
	int i;

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

		if (!ubi_check_volumename(ubi->volumes[i], name))
			return 0;
	}

	return 1;
}


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) {
		printf("No space left in UBI device!\n");
		err = ENOMEM;
		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) {
		printf("Name too long!\n");
		err = ENAMETOOLONG;
		goto bad;
	}

	return 0;
bad:
	return err;
}

static int ubi_create_vol(char *volume, int64_t 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 %lld\n",
		dynamic ? "dynamic" : "static", volume, size);
	/* Call real ubi create volume */
	return ubi_create_volume(ubi, &req);
}

static struct ubi_volume *ubi_find_volume(char *volume)
{
	struct ubi_volume *vol = NULL;
	int i;

	for (i = 0; i < ubi->vtbl_slots; i++) {
		vol = ubi->volumes[i];
		if (vol && !strcmp(vol->name, volume))
			return vol;
	}

	printf("Volume %s not found!\n", volume);
	return NULL;
}

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

	vol = ubi_find_volume(volume);
	if (vol == NULL)
		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->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->vol_id]->eba_tbl = NULL;
	ubi->volumes[vol->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(ubi, "cannot remove volume %s, error %d", volume, err);
	if (err < 0)
		err = -err;
	return err;
}

static int ubi_volume_continue_write(char *volume, void *buf, size_t size)
{
	int err = 1;
	struct ubi_volume *vol;

	vol = ubi_find_volume(volume);
	if (vol == NULL)
		return ENODEV;

	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(ubi, "volume %d on UBI device %d is corrupt",
				 vol->vol_id, ubi->ubi_num);
			vol->corrupted = 1;
		}

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

	return 0;
}

int ubi_volume_begin_write(char *volume, void *buf, size_t size,
	size_t full_size)
{
	int err = 1;
	int rsvd_bytes = 0;
	struct ubi_volume *vol;

	vol = ubi_find_volume(volume);
	if (vol == NULL)
		return ENODEV;

	rsvd_bytes = vol->reserved_pebs * (ubi->leb_size - vol->data_pad);
	if (size < 0 || size > rsvd_bytes) {
		printf("size > volume size! Aborting!\n");
		return EINVAL;
	}

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

	return ubi_volume_continue_write(volume, buf, size);
}

int ubi_volume_write(char *volume, void *buf, size_t size)
{
	return ubi_volume_begin_write(volume, buf, size, size);
}

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

	vol = ubi_find_volume(volume);
	if (vol == NULL)
		return ENODEV;

	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("No size specified -> Using max size (%lld)\n", 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)
		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_cache_aligned(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);
			err = -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;
}

static int ubi_dev_scan(struct mtd_info *info, char *ubidev,
		const char *vid_header_offset)
{
	struct mtd_device *dev;
	struct part_info *part;
	struct mtd_partition mtd_part;
	char ubi_mtd_param_buffer[80];
	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);

	strcpy(ubi_mtd_param_buffer, buffer);
	if (vid_header_offset)
		sprintf(ubi_mtd_param_buffer, "mtd=%d,%s", pnum,
				vid_header_offset);
	err = ubi_mtd_param_parse(ubi_mtd_param_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;
}

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

#ifdef CONFIG_CMD_UBIFS
	/*
	 * Automatically unmount UBIFS partition when user
	 * changes the UBI device. Otherwise the following
	 * UBIFS commands will crash.
	 */
	if (ubifs_is_mounted())
		cmd_ubifs_umount();
#endif

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

	ubi_dev.selected = 0;
	return 0;
}

int ubi_part(char *part_name, const char *vid_header_offset)
{
	int err = 0;
	char mtd_dev[16];
	struct mtd_device *dev;
	struct part_info *part;
	u8 pnum;

	ubi_detach();
	/*
	 * Search the mtd device number where this partition
	 * is located
	 */
	if (find_dev_and_part(part_name, &dev, &pnum, &part)) {
		printf("Partition %s not found!\n", part_name);
		return 1;
	}
	sprintf(mtd_dev, "%s%d", MTD_DEV_TYPE(dev->id->type), dev->id->num);
	ubi_dev.mtd_info = get_mtd_device_nm(mtd_dev);
	if (IS_ERR(ubi_dev.mtd_info)) {
		printf("Partition %s not found on device %s!\n", part_name,
		       mtd_dev);
		return 1;
	}

	ubi_dev.selected = 1;

	strcpy(ubi_dev.part_name, part_name);
	err = ubi_dev_scan(ubi_dev.mtd_info, ubi_dev.part_name,
			vid_header_offset);
	if (err) {
		printf("UBI init error %d\n", err);
		ubi_dev.selected = 0;
		return err;
	}

	ubi = ubi_devices[0];

	return 0;
}

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

	if (argc < 2)
		return CMD_RET_USAGE;


	if (strcmp(argv[1], "detach") == 0) {
		if (argc < 2)
			return CMD_RET_USAGE;

		return ubi_detach();
	}


	if (strcmp(argv[1], "part") == 0) {
		const char *vid_header_offset = NULL;

		/* Print current partition */
		if (argc == 2) {
			if (!ubi_dev.selected) {
				printf("Error, no UBI device/partition selected!\n");
				return 1;
			}

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

		if (argc < 3)
			return CMD_RET_USAGE;

		if (argc > 3)
			vid_header_offset = argv[3];

		return ubi_part(argv[2], vid_header_offset);
	}

	if ((strcmp(argv[1], "part") != 0) && (!ubi_dev.selected)) {
		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 (strcmp(argv[1], "check") == 0) {
		if (argc > 2)
			return ubi_check(argv[2]);

		printf("Error, no volume name passed\n");
		return 1;
	}

	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_strtoull(argv[3], NULL, 16);
			argc--;
		}
		/* Use maximum available size */
		if (!size) {
			size = (int64_t)ubi->avail_pebs * ubi->leb_size;
			printf("No size specified -> Using max size (%lld)\n", 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) {
		int ret;

		if (argc < 5) {
			printf("Please see usage\n");
			return 1;
		}

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

		if (strlen(argv[1]) == 10 &&
		    strncmp(argv[1] + 5, ".part", 5) == 0) {
			if (argc < 6) {
				ret = ubi_volume_continue_write(argv[3],
						(void *)addr, size);
			} else {
				size_t full_size;
				full_size = simple_strtoul(argv[5], NULL, 16);
				ret = ubi_volume_begin_write(argv[3],
						(void *)addr, size, full_size);
			}
		} else {
			ret = ubi_volume_write(argv[3], (void *)addr, size);
		}
		if (!ret) {
			printf("%lld bytes written to volume %s\n", size,
			       argv[3]);
		}

		return ret;
	}

	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) {
			printf("Read %lld bytes from volume %s to %lx\n", size,
			       argv[3], addr);

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