[J-u-boot.git] / common / cmd_sf.c

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

#include <common.h>
#include <div64.h>
#include <dm.h>
#include <malloc.h>
#include <mapmem.h>
#include <spi.h>
#include <spi_flash.h>

#include <asm/io.h>
#include <dm/device-internal.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;
	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	char *endp;
#ifdef CONFIG_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;
	}

#ifdef CONFIG_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);
		device_unbind(new);
	}
	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
	new = spi_flash_probe(bus, cs, speed, mode);
	if (!new) {
		printf("Failed to initialize SPI flash at %u:%u\n", bus, cs);
		return 1;
	}

	if (flash)
		spi_flash_free(flash);
	flash = new;
#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)
{
	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";
	/* Write the initial part of the block from the source */
	if (spi_flash_write(flash, offset, len, buf))
		return "write";
	/* If it's a partial sector, rewrite the existing part */
	if (len != flash->sector_size) {
		/* Rewrite the original data to the end of the sector */
		if (spi_flash_write(flash, offset + len,
				    flash->sector_size - len, &cmp_buf[len]))
			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 = malloc(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;
	unsigned long offset;
	unsigned long len;
	void *buf;
	char *endp;
	int ret = 1;

	if (argc < 4)
		return -1;

	addr = simple_strtoul(argv[1], &endp, 16);
	if (*argv[1] == 0 || *endp != 0)
		return -1;
	offset = simple_strtoul(argv[2], &endp, 16);
	if (*argv[2] == 0 || *endp != 0)
		return -1;
	len = simple_strtoul(argv[3], &endp, 16);
	if (*argv[3] == 0 || *endp != 0)
		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) {
		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: %s\n", (size_t)len, (u32)offset,
		       read ? "Read" : "Written", ret ? "ERROR" : "OK");
	}

	unmap_physmem(buf, len);

	return ret == 0 ? 0 : 1;
}

static int do_spi_flash_erase(int argc, char * const argv[])
{
	unsigned long offset;
	unsigned long len;
	char *endp;
	int ret;

	if (argc < 3)
		return -1;

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

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

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

	ret = spi_flash_erase(flash, offset, len);
	printf("SF: %zu bytes @ %#x Erased: %s\n", (size_t)len, (u32)offset,
	       ret ? "ERROR" : "OK");

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