[J-u-boot.git] / cmd / sf.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Command for accessing SPI flash.
 *
 * Copyright (C) 2008 Atmel Corporation
 */

#include <common.h>
#include <command.h>
#include <div64.h>
#include <dm.h>
#include <flash.h>
#include <log.h>
#include <malloc.h>
#include <mapmem.h>
#include <spi.h>
#include <spi_flash.h>
#include <asm/cache.h>
#include <jffs2/jffs2.h>
#include <linux/mtd/mtd.h>

#include <asm/io.h>
#include <dm/device-internal.h>

#include "legacy-mtd-utils.h"

static struct spi_flash *flash;

/*
 * This function computes the length argument for the erase command.
 * The length on which the command is to operate can be given in two forms:
 * 1. <cmd> offset len  - operate on <'offset',  'len')
 * 2. <cmd> offset +len - operate on <'offset',  'round_up(len)')
 * If the second form is used and the length doesn't fall on the
 * sector boundary, than it will be adjusted to the next sector boundary.
 * If it isn't in the flash, the function will fail (return -1).
 * Input:
 *    arg: length specification (i.e. both command arguments)
 * Output:
 *    len: computed length for operation
 * Return:
 *    1: success
 *   -1: failure (bad format, bad address).
 */
static int sf_parse_len_arg(char *arg, ulong *len)
{
	char *ep;
	char round_up_len; /* indicates if the "+length" form used */
	ulong len_arg;

	round_up_len = 0;
	if (*arg == '+') {
		round_up_len = 1;
		++arg;
	}

	len_arg = simple_strtoul(arg, &ep, 16);
	if (ep == arg || *ep != '\0')
		return -1;

	if (round_up_len && flash->sector_size > 0)
		*len = ROUND(len_arg, flash->sector_size);
	else
		*len = len_arg;

	return 1;
}

/**
 * This function takes a byte length and a delta unit of time to compute the
 * approximate bytes per second
 *
 * @param len		amount of bytes currently processed
 * @param start_ms	start time of processing in ms
 * @return bytes per second if OK, 0 on error
 */
static ulong bytes_per_second(unsigned int len, ulong start_ms)
{
	/* less accurate but avoids overflow */
	if (len >= ((unsigned int) -1) / 1024)
		return len / (max(get_timer(start_ms) / 1024, 1UL));
	else
		return 1024 * len / max(get_timer(start_ms), 1UL);
}

static int do_spi_flash_probe(int argc, char *const argv[])
{
	unsigned int bus = CONFIG_SF_DEFAULT_BUS;
	unsigned int cs = CONFIG_SF_DEFAULT_CS;
	/* In DM mode, defaults speed and mode will be taken from DT */
	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	char *endp;
#if CONFIG_IS_ENABLED(DM_SPI_FLASH)
	struct udevice *new, *bus_dev;
	int ret;
#else
	struct spi_flash *new;
#endif

	if (argc >= 2) {
		cs = simple_strtoul(argv[1], &endp, 0);
		if (*argv[1] == 0 || (*endp != 0 && *endp != ':'))
			return -1;
		if (*endp == ':') {
			if (endp[1] == 0)
				return -1;

			bus = cs;
			cs = simple_strtoul(endp + 1, &endp, 0);
			if (*endp != 0)
				return -1;
		}
	}

	if (argc >= 3) {
		speed = simple_strtoul(argv[2], &endp, 0);
		if (*argv[2] == 0 || *endp != 0)
			return -1;
	}
	if (argc >= 4) {
		mode = simple_strtoul(argv[3], &endp, 16);
		if (*argv[3] == 0 || *endp != 0)
			return -1;
	}

#if CONFIG_IS_ENABLED(DM_SPI_FLASH)
	/* Remove the old device, otherwise probe will just be a nop */
	ret = spi_find_bus_and_cs(bus, cs, &bus_dev, &new);
	if (!ret) {
		device_remove(new, DM_REMOVE_NORMAL);
	}
	flash = NULL;
	ret = spi_flash_probe_bus_cs(bus, cs, speed, mode, &new);
	if (ret) {
		printf("Failed to initialize SPI flash at %u:%u (error %d)\n",
		       bus, cs, ret);
		return 1;
	}

	flash = dev_get_uclass_priv(new);
#else
	if (flash)
		spi_flash_free(flash);

	new = spi_flash_probe(bus, cs, speed, mode);
	flash = new;
	if (!new) {
		printf("Failed to initialize SPI flash at %u:%u\n", bus, cs);
		return 1;
	}
#endif

	return 0;
}

/**
 * Write a block of data to SPI flash, first checking if it is different from
 * what is already there.
 *
 * If the data being written is the same, then *skipped is incremented by len.
 *
 * @param flash		flash context pointer
 * @param offset	flash offset to write
 * @param len		number of bytes to write
 * @param buf		buffer to write from
 * @param cmp_buf	read buffer to use to compare data
 * @param skipped	Count of skipped data (incremented by this function)
 * @return NULL if OK, else a string containing the stage which failed
 */
static const char *spi_flash_update_block(struct spi_flash *flash, u32 offset,
		size_t len, const char *buf, char *cmp_buf, size_t *skipped)
{
	char *ptr = (char *)buf;

	debug("offset=%#x, sector_size=%#x, len=%#zx\n",
	      offset, flash->sector_size, len);
	/* Read the entire sector so to allow for rewriting */
	if (spi_flash_read(flash, offset, flash->sector_size, cmp_buf))
		return "read";
	/* Compare only what is meaningful (len) */
	if (memcmp(cmp_buf, buf, len) == 0) {
		debug("Skip region %x size %zx: no change\n",
		      offset, len);
		*skipped += len;
		return NULL;
	}
	/* Erase the entire sector */
	if (spi_flash_erase(flash, offset, flash->sector_size))
		return "erase";
	/* If it's a partial sector, copy the data into the temp-buffer */
	if (len != flash->sector_size) {
		memcpy(cmp_buf, buf, len);
		ptr = cmp_buf;
	}
	/* Write one complete sector */
	if (spi_flash_write(flash, offset, flash->sector_size, ptr))
		return "write";

	return NULL;
}

/**
 * Update an area of SPI flash by erasing and writing any blocks which need
 * to change. Existing blocks with the correct data are left unchanged.
 *
 * @param flash		flash context pointer
 * @param offset	flash offset to write
 * @param len		number of bytes to write
 * @param buf		buffer to write from
 * @return 0 if ok, 1 on error
 */
static int spi_flash_update(struct spi_flash *flash, u32 offset,
		size_t len, const char *buf)
{
	const char *err_oper = NULL;
	char *cmp_buf;
	const char *end = buf + len;
	size_t todo;		/* number of bytes to do in this pass */
	size_t skipped = 0;	/* statistics */
	const ulong start_time = get_timer(0);
	size_t scale = 1;
	const char *start_buf = buf;
	ulong delta;

	if (end - buf >= 200)
		scale = (end - buf) / 100;
	cmp_buf = memalign(ARCH_DMA_MINALIGN, flash->sector_size);
	if (cmp_buf) {
		ulong last_update = get_timer(0);

		for (; buf < end && !err_oper; buf += todo, offset += todo) {
			todo = min_t(size_t, end - buf, flash->sector_size);
			if (get_timer(last_update) > 100) {
				printf("   \rUpdating, %zu%% %lu B/s",
				       100 - (end - buf) / scale,
					bytes_per_second(buf - start_buf,
							 start_time));
				last_update = get_timer(0);
			}
			err_oper = spi_flash_update_block(flash, offset, todo,
					buf, cmp_buf, &skipped);
		}
	} else {
		err_oper = "malloc";
	}
	free(cmp_buf);
	putc('\r');
	if (err_oper) {
		printf("SPI flash failed in %s step\n", err_oper);
		return 1;
	}

	delta = get_timer(start_time);
	printf("%zu bytes written, %zu bytes skipped", len - skipped,
	       skipped);
	printf(" in %ld.%lds, speed %ld B/s\n",
	       delta / 1000, delta % 1000, bytes_per_second(len, start_time));

	return 0;
}

static int do_spi_flash_read_write(int argc, char *const argv[])
{
	unsigned long addr;
	void *buf;
	char *endp;
	int ret = 1;
	int dev = 0;
	loff_t offset, len, maxsize;

	if (argc < 3)
		return -1;

	addr = simple_strtoul(argv[1], &endp, 16);
	if (*argv[1] == 0 || *endp != 0)
		return -1;

	if (mtd_arg_off_size(argc - 2, &argv[2], &dev, &offset, &len,
			     &maxsize, MTD_DEV_TYPE_NOR, flash->size))
		return -1;

	/* Consistency checking */
	if (offset + len > flash->size) {
		printf("ERROR: attempting %s past flash size (%#x)\n",
		       argv[0], flash->size);
		return 1;
	}

	buf = map_physmem(addr, len, MAP_WRBACK);
	if (!buf && addr) {
		puts("Failed to map physical memory\n");
		return 1;
	}

	if (strcmp(argv[0], "update") == 0) {
		ret = spi_flash_update(flash, offset, len, buf);
	} else if (strncmp(argv[0], "read", 4) == 0 ||
			strncmp(argv[0], "write", 5) == 0) {
		int read;

		read = strncmp(argv[0], "read", 4) == 0;
		if (read)
			ret = spi_flash_read(flash, offset, len, buf);
		else
			ret = spi_flash_write(flash, offset, len, buf);

		printf("SF: %zu bytes @ %#x %s: ", (size_t)len, (u32)offset,
		       read ? "Read" : "Written");
		if (ret)
			printf("ERROR %d\n", ret);
		else
			printf("OK\n");
	}

	unmap_physmem(buf, len);

	return ret == 0 ? 0 : 1;
}

static int do_spi_flash_erase(int argc, char *const argv[])
{
	int ret;
	int dev = 0;
	loff_t offset, len, maxsize;
	ulong size;

	if (argc < 3)
		return -1;

	if (mtd_arg_off(argv[1], &dev, &offset, &len, &maxsize,
			MTD_DEV_TYPE_NOR, flash->size))
		return -1;

	ret = sf_parse_len_arg(argv[2], &size);
	if (ret != 1)
		return -1;

	/* Consistency checking */
	if (offset + size > flash->size) {
		printf("ERROR: attempting %s past flash size (%#x)\n",
		       argv[0], flash->size);
		return 1;
	}

	ret = spi_flash_erase(flash, offset, size);
	printf("SF: %zu bytes @ %#x Erased: ", (size_t)size, (u32)offset);
	if (ret)
		printf("ERROR %d\n", ret);
	else
		printf("OK\n");

	return ret == 0 ? 0 : 1;
}

static int do_spi_protect(int argc, char *const argv[])
{
	int ret = 0;
	loff_t start, len;
	bool prot = false;

	if (argc != 4)
		return -1;

	if (!str2off(argv[2], &start)) {
		puts("start sector is not a valid number\n");
		return 1;
	}

	if (!str2off(argv[3], &len)) {
		puts("len is not a valid number\n");
		return 1;
	}

	if (strcmp(argv[1], "lock") == 0)
		prot = true;
	else if (strcmp(argv[1], "unlock") == 0)
		prot = false;
	else
		return -1;  /* Unknown parameter */

	ret = spi_flash_protect(flash, start, len, prot);

	return ret == 0 ? 0 : 1;
}

#ifdef CONFIG_CMD_SF_TEST
enum {
	STAGE_ERASE,
	STAGE_CHECK,
	STAGE_WRITE,
	STAGE_READ,

	STAGE_COUNT,
};

static char *stage_name[STAGE_COUNT] = {
	"erase",
	"check",
	"write",
	"read",
};

struct test_info {
	int stage;
	int bytes;
	unsigned base_ms;
	unsigned time_ms[STAGE_COUNT];
};

static void show_time(struct test_info *test, int stage)
{
	uint64_t speed;	/* KiB/s */
	int bps;	/* Bits per second */

	speed = (long long)test->bytes * 1000;
	if (test->time_ms[stage])
		do_div(speed, test->time_ms[stage] * 1024);
	bps = speed * 8;

	printf("%d %s: %u ticks, %d KiB/s %d.%03d Mbps\n", stage,
	       stage_name[stage], test->time_ms[stage],
	       (int)speed, bps / 1000, bps % 1000);
}

static void spi_test_next_stage(struct test_info *test)
{
	test->time_ms[test->stage] = get_timer(test->base_ms);
	show_time(test, test->stage);
	test->base_ms = get_timer(0);
	test->stage++;
}

/**
 * Run a test on the SPI flash
 *
 * @param flash		SPI flash to use
 * @param buf		Source buffer for data to write
 * @param len		Size of data to read/write
 * @param offset	Offset within flash to check
 * @param vbuf		Verification buffer
 * @return 0 if ok, -1 on error
 */
static int spi_flash_test(struct spi_flash *flash, uint8_t *buf, ulong len,
			   ulong offset, uint8_t *vbuf)
{
	struct test_info test;
	int i;

	printf("SPI flash test:\n");
	memset(&test, '\0', sizeof(test));
	test.base_ms = get_timer(0);
	test.bytes = len;
	if (spi_flash_erase(flash, offset, len)) {
		printf("Erase failed\n");
		return -1;
	}
	spi_test_next_stage(&test);

	if (spi_flash_read(flash, offset, len, vbuf)) {
		printf("Check read failed\n");
		return -1;
	}
	for (i = 0; i < len; i++) {
		if (vbuf[i] != 0xff) {
			printf("Check failed at %d\n", i);
			print_buffer(i, vbuf + i, 1,
				     min_t(uint, len - i, 0x40), 0);
			return -1;
		}
	}
	spi_test_next_stage(&test);

	if (spi_flash_write(flash, offset, len, buf)) {
		printf("Write failed\n");
		return -1;
	}
	memset(vbuf, '\0', len);
	spi_test_next_stage(&test);

	if (spi_flash_read(flash, offset, len, vbuf)) {
		printf("Read failed\n");
		return -1;
	}
	spi_test_next_stage(&test);

	for (i = 0; i < len; i++) {
		if (buf[i] != vbuf[i]) {
			printf("Verify failed at %d, good data:\n", i);
			print_buffer(i, buf + i, 1,
				     min_t(uint, len - i, 0x40), 0);
			printf("Bad data:\n");
			print_buffer(i, vbuf + i, 1,
				     min_t(uint, len - i, 0x40), 0);
			return -1;
		}
	}
	printf("Test passed\n");
	for (i = 0; i < STAGE_COUNT; i++)
		show_time(&test, i);

	return 0;
}

static int do_spi_flash_test(int argc, char *const argv[])
{
	unsigned long offset;
	unsigned long len;
	uint8_t *buf, *from;
	char *endp;
	uint8_t *vbuf;
	int ret;

	if (argc < 3)
		return -1;
	offset = simple_strtoul(argv[1], &endp, 16);
	if (*argv[1] == 0 || *endp != 0)
		return -1;
	len = simple_strtoul(argv[2], &endp, 16);
	if (*argv[2] == 0 || *endp != 0)
		return -1;

	vbuf = memalign(ARCH_DMA_MINALIGN, len);
	if (!vbuf) {
		printf("Cannot allocate memory (%lu bytes)\n", len);
		return 1;
	}
	buf = memalign(ARCH_DMA_MINALIGN, len);
	if (!buf) {
		free(vbuf);
		printf("Cannot allocate memory (%lu bytes)\n", len);
		return 1;
	}

	from = map_sysmem(CONFIG_SYS_TEXT_BASE, 0);
	memcpy(buf, from, len);
	ret = spi_flash_test(flash, buf, len, offset, vbuf);
	free(vbuf);
	free(buf);
	if (ret) {
		printf("Test failed\n");
		return 1;
	}

	return 0;
}
#endif /* CONFIG_CMD_SF_TEST */

static int do_spi_flash(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	const char *cmd;
	int ret;

	/* need at least two arguments */
	if (argc < 2)
		goto usage;

	cmd = argv[1];
	--argc;
	++argv;

	if (strcmp(cmd, "probe") == 0) {
		ret = do_spi_flash_probe(argc, argv);
		goto done;
	}

	/* The remaining commands require a selected device */
	if (!flash) {
		puts("No SPI flash selected. Please run `sf probe'\n");
		return 1;
	}

	if (strcmp(cmd, "read") == 0 || strcmp(cmd, "write") == 0 ||
	    strcmp(cmd, "update") == 0)
		ret = do_spi_flash_read_write(argc, argv);
	else if (strcmp(cmd, "erase") == 0)
		ret = do_spi_flash_erase(argc, argv);
	else if (strcmp(cmd, "protect") == 0)
		ret = do_spi_protect(argc, argv);
#ifdef CONFIG_CMD_SF_TEST
	else if (!strcmp(cmd, "test"))
		ret = do_spi_flash_test(argc, argv);
#endif
	else
		ret = -1;

done:
	if (ret != -1)
		return ret;

usage:
	return CMD_RET_USAGE;
}

#ifdef CONFIG_CMD_SF_TEST
#define SF_TEST_HELP "\nsf test offset len		" \
		"- run a very basic destructive test"
#else
#define SF_TEST_HELP
#endif

U_BOOT_CMD(
	sf,	5,	1,	do_spi_flash,
	"SPI flash sub-system",
	"probe [[bus:]cs] [hz] [mode]	- init flash device on given SPI bus\n"
	"				  and chip select\n"
	"sf read addr offset|partition len	- read `len' bytes starting at\n"
	"				          `offset' or from start of mtd\n"
	"					  `partition'to memory at `addr'\n"
	"sf write addr offset|partition len	- write `len' bytes from memory\n"
	"				          at `addr' to flash at `offset'\n"
	"					  or to start of mtd `partition'\n"
	"sf erase offset|partition [+]len	- erase `len' bytes from `offset'\n"
	"					  or from start of mtd `partition'\n"
	"					 `+len' round up `len' to block size\n"
	"sf update addr offset|partition len	- erase and write `len' bytes from memory\n"
	"					  at `addr' to flash at `offset'\n"
	"					  or to start of mtd `partition'\n"
	"sf protect lock/unlock sector len	- protect/unprotect 'len' bytes starting\n"
	"					  at address 'sector'\n"
	SF_TEST_HELP
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
b6368467 HS	2	/*
	3	* Command for accessing SPI flash.
	4	*
	5	* Copyright (C) 2008 Atmel Corporation
	6	*/
4166ee58	7
b6368467	8	#include <common.h>
09140113	9	#include <command.h>
381c6e2c	10	#include <div64.h>
fbb09918	11	#include <dm.h>
b79fdc76	12	#include <flash.h>
f7ae49fc	13	#include <log.h>
8d1af942	14	#include <malloc.h>
0eb25b61	15	#include <mapmem.h>
ff0960f9	16	#include <spi.h>
b6368467	17	#include <spi_flash.h>
90526e9f	18	#include <asm/cache.h>
2ec1a405 HS	19	#include <jffs2/jffs2.h>
2ec1a405 HS	20	#include <linux/mtd/mtd.h>
b6368467 HS	21
b6368467 HS	22	#include <asm/io.h>
fbb09918	23	#include <dm/device-internal.h>
b6368467	24
eb446ef6 MR	25	#include "legacy-mtd-utils.h"
eb446ef6 MR	26
b6368467 HS	27	static struct spi_flash *flash;
b6368467 HS	28
334eb4b0 RR	29	/*
	30	* This function computes the length argument for the erase command.
	31	* The length on which the command is to operate can be given in two forms:
	32	* 1. <cmd> offset len - operate on <'offset', 'len')
	33	* 2. <cmd> offset +len - operate on <'offset', 'round_up(len)')
	34	* If the second form is used and the length doesn't fall on the
	35	* sector boundary, than it will be adjusted to the next sector boundary.
	36	* If it isn't in the flash, the function will fail (return -1).
	37	* Input:
	38	* arg: length specification (i.e. both command arguments)
	39	* Output:
	40	* len: computed length for operation
	41	* Return:
	42	* 1: success
	43	* -1: failure (bad format, bad address).
	44	*/
	45	static int sf_parse_len_arg(char arg, ulong len)
	46	{
	47	char *ep;
	48	char round_up_len; /* indicates if the "+length" form used */
	49	ulong len_arg;
	50
	51	round_up_len = 0;
	52	if (*arg == '+') {
	53	round_up_len = 1;
	54	++arg;
	55	}
	56
	57	len_arg = simple_strtoul(arg, &ep, 16);
	58	if (ep == arg \|\| *ep != '\0')
	59	return -1;
	60
	61	if (round_up_len && flash->sector_size > 0)
155cfb5e	62	*len = ROUND(len_arg, flash->sector_size);
334eb4b0 RR	63	else
	64	*len = len_arg;
	65
	66	return 1;
	67	}
	68
a683c288 JM	69	/**
	70	* This function takes a byte length and a delta unit of time to compute the
	71	* approximate bytes per second
	72	*
	73	* @param len amount of bytes currently processed
	74	* @param start_ms start time of processing in ms
	75	* @return bytes per second if OK, 0 on error
	76	*/
	77	static ulong bytes_per_second(unsigned int len, ulong start_ms)
	78	{
	79	/* less accurate but avoids overflow */
	80	if (len >= ((unsigned int) -1) / 1024)
b4141195	81	return len / (max(get_timer(start_ms) / 1024, 1UL));
a683c288	82	else
b4141195	83	return 1024 * len / max(get_timer(start_ms), 1UL);
a683c288 JM	84	}
a683c288 JM	85
09140113	86	static int do_spi_flash_probe(int argc, char *const argv[])
b6368467	87	{
c1173bd0 EN	88	unsigned int bus = CONFIG_SF_DEFAULT_BUS;
c1173bd0 EN	89	unsigned int cs = CONFIG_SF_DEFAULT_CS;
b0cc1b84	90	/* In DM mode, defaults speed and mode will be taken from DT */
b6368467 HS	91	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	92	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	93	char *endp;
56c40460	94	#if CONFIG_IS_ENABLED(DM_SPI_FLASH)
fbb09918 SG	95	struct udevice new, bus_dev;
	96	int ret;
	97	#else
b6368467	98	struct spi_flash *new;
fbb09918	99	#endif
b6368467	100
c1173bd0 EN	101	if (argc >= 2) {
	102	cs = simple_strtoul(argv[1], &endp, 0);
	103	if (argv[1] == 0 \|\| (endp != 0 && *endp != ':'))
8a07de03	104	return -1;
c1173bd0 EN	105	if (*endp == ':') {
	106	if (endp[1] == 0)
	107	return -1;
	108
	109	bus = cs;
	110	cs = simple_strtoul(endp + 1, &endp, 0);
	111	if (*endp != 0)
	112	return -1;
	113	}
b6368467 HS	114	}
	115
	116	if (argc >= 3) {
	117	speed = simple_strtoul(argv[2], &endp, 0);
	118	if (argv[2] == 0 \|\| endp != 0)
8a07de03	119	return -1;
b6368467 HS	120	}
b6368467 HS	121	if (argc >= 4) {
6e8d58d3	122	mode = simple_strtoul(argv[3], &endp, 16);
b6368467	123	if (argv[3] == 0 \|\| endp != 0)
8a07de03	124	return -1;
b6368467 HS	125	}
b6368467 HS	126
56c40460	127	#if CONFIG_IS_ENABLED(DM_SPI_FLASH)
fbb09918 SG	128	/* Remove the old device, otherwise probe will just be a nop */
	129	ret = spi_find_bus_and_cs(bus, cs, &bus_dev, &new);
	130	if (!ret) {
706865af	131	device_remove(new, DM_REMOVE_NORMAL);
fbb09918 SG	132	}
	133	flash = NULL;
	134	ret = spi_flash_probe_bus_cs(bus, cs, speed, mode, &new);
	135	if (ret) {
	136	printf("Failed to initialize SPI flash at %u:%u (error %d)\n",
	137	bus, cs, ret);
	138	return 1;
	139	}
	140
e564f054	141	flash = dev_get_uclass_priv(new);
fbb09918	142	#else
8ee81b7f HS	143	if (flash)
	144	spi_flash_free(flash);
	145
b6368467	146	new = spi_flash_probe(bus, cs, speed, mode);
8ee81b7f	147	flash = new;
b6368467 HS	148	if (!new) {
	149	printf("Failed to initialize SPI flash at %u:%u\n", bus, cs);
	150	return 1;
	151	}
fbb09918	152	#endif
b6368467	153
b6368467	154	return 0;
b6368467 HS	155	}
b6368467 HS	156
8d1af942 SG	157	/**
	158	* Write a block of data to SPI flash, first checking if it is different from
	159	* what is already there.
	160	*
	161	* If the data being written is the same, then *skipped is incremented by len.
	162	*
	163	* @param flash flash context pointer
	164	* @param offset flash offset to write
	165	* @param len number of bytes to write
	166	* @param buf buffer to write from
	167	* @param cmp_buf read buffer to use to compare data
	168	* @param skipped Count of skipped data (incremented by this function)
	169	* @return NULL if OK, else a string containing the stage which failed
	170	*/
	171	static const char spi_flash_update_block(struct spi_flash flash, u32 offset,
	172	size_t len, const char buf, char cmp_buf, size_t *skipped)
	173	{
ed62756d SR	174	char ptr = (char )buf;
ed62756d SR	175
a97f6efd	176	debug("offset=%#x, sector_size=%#x, len=%#zx\n",
402ba1e3	177	offset, flash->sector_size, len);
b95f958d GF	178	/* Read the entire sector so to allow for rewriting */
b95f958d GF	179	if (spi_flash_read(flash, offset, flash->sector_size, cmp_buf))
8d1af942	180	return "read";
b95f958d	181	/* Compare only what is meaningful (len) */
8d1af942	182	if (memcmp(cmp_buf, buf, len) == 0) {
a97f6efd	183	debug("Skip region %x size %zx: no change\n",
402ba1e3	184	offset, len);
8d1af942 SG	185	*skipped += len;
	186	return NULL;
	187	}
34888506 GF	188	/* Erase the entire sector */
34888506 GF	189	if (spi_flash_erase(flash, offset, flash->sector_size))
8d1af942	190	return "erase";
ed62756d	191	/* If it's a partial sector, copy the data into the temp-buffer */
b95f958d	192	if (len != flash->sector_size) {
ed62756d SR	193	memcpy(cmp_buf, buf, len);
ed62756d SR	194	ptr = cmp_buf;
b95f958d	195	}
ed62756d SR	196	/* Write one complete sector */
	197	if (spi_flash_write(flash, offset, flash->sector_size, ptr))
	198	return "write";
b95f958d	199
8d1af942 SG	200	return NULL;
	201	}
	202
	203	/**
	204	* Update an area of SPI flash by erasing and writing any blocks which need
	205	* to change. Existing blocks with the correct data are left unchanged.
	206	*
	207	* @param flash flash context pointer
	208	* @param offset flash offset to write
	209	* @param len number of bytes to write
	210	* @param buf buffer to write from
	211	* @return 0 if ok, 1 on error
	212	*/
	213	static int spi_flash_update(struct spi_flash *flash, u32 offset,
	214	size_t len, const char *buf)
	215	{
	216	const char *err_oper = NULL;
	217	char *cmp_buf;
	218	const char *end = buf + len;
	219	size_t todo; /* number of bytes to do in this pass */
8e8a4bc2	220	size_t skipped = 0; /* statistics */
a683c288 JM	221	const ulong start_time = get_timer(0);
	222	size_t scale = 1;
	223	const char *start_buf = buf;
	224	ulong delta;
8d1af942	225
a683c288 JM	226	if (end - buf >= 200)
a683c288 JM	227	scale = (end - buf) / 100;
156e96f0	228	cmp_buf = memalign(ARCH_DMA_MINALIGN, flash->sector_size);
8d1af942	229	if (cmp_buf) {
a683c288 JM	230	ulong last_update = get_timer(0);
a683c288 JM	231
8e8a4bc2	232	for (; buf < end && !err_oper; buf += todo, offset += todo) {
b4141195	233	todo = min_t(size_t, end - buf, flash->sector_size);
a683c288 JM	234	if (get_timer(last_update) > 100) {
a683c288 JM	235	printf(" \rUpdating, %zu%% %lu B/s",
402ba1e3	236	100 - (end - buf) / scale,
a683c288 JM	237	bytes_per_second(buf - start_buf,
	238	start_time));
	239	last_update = get_timer(0);
	240	}
8d1af942 SG	241	err_oper = spi_flash_update_block(flash, offset, todo,
	242	buf, cmp_buf, &skipped);
	243	}
	244	} else {
	245	err_oper = "malloc";
	246	}
	247	free(cmp_buf);
a683c288	248	putc('\r');
8d1af942 SG	249	if (err_oper) {
	250	printf("SPI flash failed in %s step\n", err_oper);
	251	return 1;
	252	}
a683c288 JM	253
	254	delta = get_timer(start_time);
	255	printf("%zu bytes written, %zu bytes skipped", len - skipped,
402ba1e3	256	skipped);
a683c288	257	printf(" in %ld.%lds, speed %ld B/s\n",
402ba1e3	258	delta / 1000, delta % 1000, bytes_per_second(len, start_time));
8e8a4bc2	259
8d1af942 SG	260	return 0;
	261	}
	262
09140113	263	static int do_spi_flash_read_write(int argc, char *const argv[])
b6368467 HS	264	{
b6368467 HS	265	unsigned long addr;
b6368467 HS	266	void *buf;
b6368467 HS	267	char *endp;
60b6614a	268	int ret = 1;
2ec1a405 HS	269	int dev = 0;
2ec1a405 HS	270	loff_t offset, len, maxsize;
b6368467	271
2ec1a405	272	if (argc < 3)
8a07de03	273	return -1;
b6368467 HS	274
	275	addr = simple_strtoul(argv[1], &endp, 16);
	276	if (argv[1] == 0 \|\| endp != 0)
8a07de03	277	return -1;
2ec1a405 HS	278
	279	if (mtd_arg_off_size(argc - 2, &argv[2], &dev, &offset, &len,
	280	&maxsize, MTD_DEV_TYPE_NOR, flash->size))
8a07de03	281	return -1;
b6368467	282
86493994 GF	283	/* Consistency checking */
	284	if (offset + len > flash->size) {
	285	printf("ERROR: attempting %s past flash size (%#x)\n",
402ba1e3	286	argv[0], flash->size);
86493994 GF	287	return 1;
	288	}
	289
b6368467	290	buf = map_physmem(addr, len, MAP_WRBACK);
10f087f7	291	if (!buf && addr) {
b6368467 HS	292	puts("Failed to map physical memory\n");
	293	return 1;
	294	}
	295
402ba1e3	296	if (strcmp(argv[0], "update") == 0) {
8d1af942	297	ret = spi_flash_update(flash, offset, len, buf);
402ba1e3	298	} else if (strncmp(argv[0], "read", 4) == 0 \|\|
60b6614a JT	299	strncmp(argv[0], "write", 5) == 0) {
	300	int read;
	301
	302	read = strncmp(argv[0], "read", 4) == 0;
	303	if (read)
	304	ret = spi_flash_read(flash, offset, len, buf);
	305	else
	306	ret = spi_flash_write(flash, offset, len, buf);
	307
a7d0711a SG	308	printf("SF: %zu bytes @ %#x %s: ", (size_t)len, (u32)offset,
	309	read ? "Read" : "Written");
	310	if (ret)
	311	printf("ERROR %d\n", ret);
	312	else
	313	printf("OK\n");
60b6614a	314	}
b6368467 HS	315
	316	unmap_physmem(buf, len);
	317
60b6614a	318	return ret == 0 ? 0 : 1;
b6368467 HS	319	}
b6368467 HS	320
09140113	321	static int do_spi_flash_erase(int argc, char *const argv[])
b6368467	322	{
b6368467	323	int ret;
2ec1a405 HS	324	int dev = 0;
	325	loff_t offset, len, maxsize;
	326	ulong size;
b6368467 HS	327
b6368467 HS	328	if (argc < 3)
8a07de03	329	return -1;
b6368467	330
2ec1a405 HS	331	if (mtd_arg_off(argv[1], &dev, &offset, &len, &maxsize,
2ec1a405 HS	332	MTD_DEV_TYPE_NOR, flash->size))
8a07de03	333	return -1;
334eb4b0	334
2ec1a405	335	ret = sf_parse_len_arg(argv[2], &size);
334eb4b0	336	if (ret != 1)
8a07de03	337	return -1;
b6368467	338
86493994	339	/* Consistency checking */
2ec1a405	340	if (offset + size > flash->size) {
86493994	341	printf("ERROR: attempting %s past flash size (%#x)\n",
402ba1e3	342	argv[0], flash->size);
86493994 GF	343	return 1;
	344	}
	345
2ec1a405	346	ret = spi_flash_erase(flash, offset, size);
1bb8ca3b SA	347	printf("SF: %zu bytes @ %#x Erased: ", (size_t)size, (u32)offset);
	348	if (ret)
	349	printf("ERROR %d\n", ret);
	350	else
	351	printf("OK\n");
b6368467	352
96bbf556	353	return ret == 0 ? 0 : 1;
b6368467 HS	354	}
b6368467 HS	355
09140113	356	static int do_spi_protect(int argc, char *const argv[])
c3c016cf FE	357	{
	358	int ret = 0;
	359	loff_t start, len;
	360	bool prot = false;
	361
	362	if (argc != 4)
	363	return -1;
	364
	365	if (!str2off(argv[2], &start)) {
	366	puts("start sector is not a valid number\n");
	367	return 1;
	368	}
	369
	370	if (!str2off(argv[3], &len)) {
	371	puts("len is not a valid number\n");
	372	return 1;
	373	}
	374
	375	if (strcmp(argv[1], "lock") == 0)
	376	prot = true;
	377	else if (strcmp(argv[1], "unlock") == 0)
	378	prot = false;
	379	else
	380	return -1; /* Unknown parameter */
	381
	382	ret = spi_flash_protect(flash, start, len, prot);
	383
	384	return ret == 0 ? 0 : 1;
	385	}
	386
24007273 SG	387	#ifdef CONFIG_CMD_SF_TEST
	388	enum {
	389	STAGE_ERASE,
	390	STAGE_CHECK,
	391	STAGE_WRITE,
	392	STAGE_READ,
	393
	394	STAGE_COUNT,
	395	};
	396
	397	static char *stage_name[STAGE_COUNT] = {
	398	"erase",
	399	"check",
	400	"write",
	401	"read",
	402	};
	403
	404	struct test_info {
	405	int stage;
	406	int bytes;
	407	unsigned base_ms;
	408	unsigned time_ms[STAGE_COUNT];
	409	};
	410
	411	static void show_time(struct test_info *test, int stage)
	412	{
	413	uint64_t speed; /* KiB/s */
	414	int bps; /* Bits per second */
	415
	416	speed = (long long)test->bytes * 1000;
d1f22d4b SG	417	if (test->time_ms[stage])
d1f22d4b SG	418	do_div(speed, test->time_ms[stage] * 1024);
24007273 SG	419	bps = speed * 8;
24007273 SG	420
c6b2ea37	421	printf("%d %s: %u ticks, %d KiB/s %d.%03d Mbps\n", stage,
24007273 SG	422	stage_name[stage], test->time_ms[stage],
	423	(int)speed, bps / 1000, bps % 1000);
	424	}
	425
	426	static void spi_test_next_stage(struct test_info *test)
	427	{
	428	test->time_ms[test->stage] = get_timer(test->base_ms);
	429	show_time(test, test->stage);
	430	test->base_ms = get_timer(0);
	431	test->stage++;
	432	}
	433
	434	/**
	435	* Run a test on the SPI flash
	436	*
	437	* @param flash SPI flash to use
	438	* @param buf Source buffer for data to write
	439	* @param len Size of data to read/write
	440	* @param offset Offset within flash to check
	441	* @param vbuf Verification buffer
	442	* @return 0 if ok, -1 on error
	443	*/
1e7133e9 SG	444	static int spi_flash_test(struct spi_flash flash, uint8_t buf, ulong len,
1e7133e9 SG	445	ulong offset, uint8_t *vbuf)
24007273 SG	446	{
	447	struct test_info test;
	448	int i;
	449
	450	printf("SPI flash test:\n");
	451	memset(&test, '\0', sizeof(test));
	452	test.base_ms = get_timer(0);
	453	test.bytes = len;
	454	if (spi_flash_erase(flash, offset, len)) {
	455	printf("Erase failed\n");
	456	return -1;
	457	}
	458	spi_test_next_stage(&test);
	459
	460	if (spi_flash_read(flash, offset, len, vbuf)) {
	461	printf("Check read failed\n");
	462	return -1;
	463	}
	464	for (i = 0; i < len; i++) {
	465	if (vbuf[i] != 0xff) {
	466	printf("Check failed at %d\n", i);
b4141195 MY	467	print_buffer(i, vbuf + i, 1,
b4141195 MY	468	min_t(uint, len - i, 0x40), 0);
24007273 SG	469	return -1;
	470	}
	471	}
	472	spi_test_next_stage(&test);
	473
	474	if (spi_flash_write(flash, offset, len, buf)) {
	475	printf("Write failed\n");
	476	return -1;
	477	}
	478	memset(vbuf, '\0', len);
	479	spi_test_next_stage(&test);
	480
	481	if (spi_flash_read(flash, offset, len, vbuf)) {
	482	printf("Read failed\n");
	483	return -1;
	484	}
	485	spi_test_next_stage(&test);
	486
	487	for (i = 0; i < len; i++) {
	488	if (buf[i] != vbuf[i]) {
	489	printf("Verify failed at %d, good data:\n", i);
b4141195 MY	490	print_buffer(i, buf + i, 1,
b4141195 MY	491	min_t(uint, len - i, 0x40), 0);
24007273	492	printf("Bad data:\n");
b4141195 MY	493	print_buffer(i, vbuf + i, 1,
b4141195 MY	494	min_t(uint, len - i, 0x40), 0);
24007273 SG	495	return -1;
	496	}
	497	}
	498	printf("Test passed\n");
	499	for (i = 0; i < STAGE_COUNT; i++)
	500	show_time(&test, i);
	501
	502	return 0;
	503	}
	504
09140113	505	static int do_spi_flash_test(int argc, char *const argv[])
24007273 SG	506	{
	507	unsigned long offset;
	508	unsigned long len;
d1f22d4b	509	uint8_t buf, from;
24007273	510	char *endp;
1e7133e9	511	uint8_t *vbuf;
24007273 SG	512	int ret;
24007273 SG	513
d1f22d4b SG	514	if (argc < 3)
d1f22d4b SG	515	return -1;
24007273 SG	516	offset = simple_strtoul(argv[1], &endp, 16);
	517	if (argv[1] == 0 \|\| endp != 0)
	518	return -1;
	519	len = simple_strtoul(argv[2], &endp, 16);
	520	if (argv[2] == 0 \|\| endp != 0)
	521	return -1;
	522
156e96f0	523	vbuf = memalign(ARCH_DMA_MINALIGN, len);
24007273	524	if (!vbuf) {
d1f22d4b	525	printf("Cannot allocate memory (%lu bytes)\n", len);
24007273 SG	526	return 1;
24007273 SG	527	}
156e96f0	528	buf = memalign(ARCH_DMA_MINALIGN, len);
24007273 SG	529	if (!buf) {
24007273 SG	530	free(vbuf);
d1f22d4b	531	printf("Cannot allocate memory (%lu bytes)\n", len);
24007273 SG	532	return 1;
	533	}
	534
d1f22d4b SG	535	from = map_sysmem(CONFIG_SYS_TEXT_BASE, 0);
d1f22d4b SG	536	memcpy(buf, from, len);
24007273 SG	537	ret = spi_flash_test(flash, buf, len, offset, vbuf);
	538	free(vbuf);
	539	free(buf);
	540	if (ret) {
	541	printf("Test failed\n");
	542	return 1;
	543	}
	544
	545	return 0;
	546	}
	547	#endif /* CONFIG_CMD_SF_TEST */
	548
09140113 SG	549	static int do_spi_flash(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	550	char *const argv[])
b6368467 HS	551	{
b6368467 HS	552	const char *cmd;
8a07de03	553	int ret;
b6368467 HS	554
	555	/* need at least two arguments */
	556	if (argc < 2)
	557	goto usage;
	558
	559	cmd = argv[1];
8a07de03 MF	560	--argc;
8a07de03 MF	561	++argv;
b6368467	562
8a07de03 MF	563	if (strcmp(cmd, "probe") == 0) {
	564	ret = do_spi_flash_probe(argc, argv);
	565	goto done;
	566	}
b6368467 HS	567
	568	/* The remaining commands require a selected device */
	569	if (!flash) {
	570	puts("No SPI flash selected. Please run `sf probe'\n");
	571	return 1;
	572	}
	573
8d1af942 SG	574	if (strcmp(cmd, "read") == 0 \|\| strcmp(cmd, "write") == 0 \|\|
8d1af942 SG	575	strcmp(cmd, "update") == 0)
8a07de03 MF	576	ret = do_spi_flash_read_write(argc, argv);
	577	else if (strcmp(cmd, "erase") == 0)
	578	ret = do_spi_flash_erase(argc, argv);
c3c016cf FE	579	else if (strcmp(cmd, "protect") == 0)
c3c016cf FE	580	ret = do_spi_protect(argc, argv);
24007273 SG	581	#ifdef CONFIG_CMD_SF_TEST
	582	else if (!strcmp(cmd, "test"))
	583	ret = do_spi_flash_test(argc, argv);
	584	#endif
8a07de03 MF	585	else
	586	ret = -1;
	587
	588	done:
	589	if (ret != -1)
	590	return ret;
b6368467 HS	591
b6368467 HS	592	usage:
4c12eeb8	593	return CMD_RET_USAGE;
b6368467 HS	594	}
b6368467 HS	595
24007273 SG	596	#ifdef CONFIG_CMD_SF_TEST
	597	#define SF_TEST_HELP "\nsf test offset len " \
	598	"- run a very basic destructive test"
	599	#else
	600	#define SF_TEST_HELP
	601	#endif
	602
b6368467 HS	603	U_BOOT_CMD(
b6368467 HS	604	sf, 5, 1, do_spi_flash,
2fb2604d	605	"SPI flash sub-system",
c1173bd0	606	"probe [[bus:]cs] [hz] [mode] - init flash device on given SPI bus\n"
b6368467	607	" and chip select\n"
2ec1a405 HS	608	"sf read addr offset\|partition len - read `len' bytes starting at\n"
	609	" `offset' or from start of mtd\n"
	610	" `partition'to memory at `addr'\n"
	611	"sf write addr offset\|partition len - write `len' bytes from memory\n"
	612	" at `addr' to flash at `offset'\n"
	613	" or to start of mtd `partition'\n"
	614	"sf erase offset\|partition [+]len - erase `len' bytes from `offset'\n"
	615	" or from start of mtd `partition'\n"
	616	" `+len' round up `len' to block size\n"
	617	"sf update addr offset\|partition len - erase and write `len' bytes from memory\n"
	618	" at `addr' to flash at `offset'\n"
	619	" or to start of mtd `partition'\n"
c3c016cf FE	620	"sf protect lock/unlock sector len - protect/unprotect 'len' bytes starting\n"
c3c016cf FE	621	" at address 'sector'\n"
24007273	622	SF_TEST_HELP
a89c33db	623	);