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

/*
 * Command for accessing SPI flash.
 *
 * Copyright (C) 2008 Atmel Corporation
 * Licensed under the GPL-2 or later.
 */

#include <common.h>
#include <malloc.h>
#include <spi_flash.h>

#include <asm/io.h>

#ifndef CONFIG_SF_DEFAULT_SPEED
# define CONFIG_SF_DEFAULT_SPEED	1000000
#endif
#ifndef CONFIG_SF_DEFAULT_MODE
# define CONFIG_SF_DEFAULT_MODE		SPI_MODE_3
#endif

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;
}

static int do_spi_flash_probe(int argc, char * const argv[])
{
	unsigned int bus = 0;
	unsigned int cs;
	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	char *endp;
	struct spi_flash *new;

	if (argc < 2)
		return -1;

	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;
	}

	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;

	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);
	if (spi_flash_read(flash, offset, len, cmp_buf))
		return "read";
	if (memcmp(cmp_buf, buf, len) == 0) {
		debug("Skip region %x size %zx: no change\n",
			offset, len);
		*skipped += len;
		return NULL;
	}
	if (spi_flash_erase(flash, offset, len))
		return "erase";
	if (spi_flash_write(flash, offset, len, buf))
		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 */

	cmp_buf = malloc(flash->sector_size);
	if (cmp_buf) {
		for (; buf < end && !err_oper; buf += todo, offset += todo) {
			todo = min(end - buf, flash->sector_size);
			err_oper = spi_flash_update_block(flash, offset, todo,
					buf, cmp_buf, &skipped);
		}
	} else {
		err_oper = "malloc";
	}
	free(cmp_buf);
	if (err_oper) {
		printf("SPI flash failed in %s step\n", err_oper);
		return 1;
	}
	printf("%zu bytes written, %zu bytes skipped\n", len - skipped,
	       skipped);

	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;

	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;

	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 (strcmp(argv[0], "read") == 0)
		ret = spi_flash_read(flash, offset, len, buf);
	else
		ret = spi_flash_write(flash, offset, len, buf);

	unmap_physmem(buf, len);

	if (ret) {
		printf("SPI flash %s failed\n", argv[0]);
		return 1;
	}

	return 0;
}

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;

	ret = spi_flash_erase(flash, offset, len);
	if (ret) {
		printf("SPI flash %s failed\n", argv[0]);
		return 1;
	}

	return 0;
}

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);
	else
		ret = -1;

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

usage:
	return cmd_usage(cmdtp);
}

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'"
);
Commit	Line	Data
b6368467 HS	1	/*
	2	* Command for accessing SPI flash.
	3	*
	4	* Copyright (C) 2008 Atmel Corporation
4166ee58	5	* Licensed under the GPL-2 or later.
b6368467	6	*/
4166ee58	7
b6368467	8	#include <common.h>
8d1af942	9	#include <malloc.h>
b6368467 HS	10	#include <spi_flash.h>
	11
	12	#include <asm/io.h>
	13
	14	#ifndef CONFIG_SF_DEFAULT_SPEED
	15	# define CONFIG_SF_DEFAULT_SPEED 1000000
	16	#endif
	17	#ifndef CONFIG_SF_DEFAULT_MODE
	18	# define CONFIG_SF_DEFAULT_MODE SPI_MODE_3
	19	#endif
	20
	21	static struct spi_flash *flash;
	22
334eb4b0 RR	23
	24	/*
	25	* This function computes the length argument for the erase command.
	26	* The length on which the command is to operate can be given in two forms:
	27	* 1. <cmd> offset len - operate on <'offset', 'len')
	28	* 2. <cmd> offset +len - operate on <'offset', 'round_up(len)')
	29	* If the second form is used and the length doesn't fall on the
	30	* sector boundary, than it will be adjusted to the next sector boundary.
	31	* If it isn't in the flash, the function will fail (return -1).
	32	* Input:
	33	* arg: length specification (i.e. both command arguments)
	34	* Output:
	35	* len: computed length for operation
	36	* Return:
	37	* 1: success
	38	* -1: failure (bad format, bad address).
	39	*/
	40	static int sf_parse_len_arg(char arg, ulong len)
	41	{
	42	char *ep;
	43	char round_up_len; /* indicates if the "+length" form used */
	44	ulong len_arg;
	45
	46	round_up_len = 0;
	47	if (*arg == '+') {
	48	round_up_len = 1;
	49	++arg;
	50	}
	51
	52	len_arg = simple_strtoul(arg, &ep, 16);
	53	if (ep == arg \|\| *ep != '\0')
	54	return -1;
	55
	56	if (round_up_len && flash->sector_size > 0)
155cfb5e	57	*len = ROUND(len_arg, flash->sector_size);
334eb4b0 RR	58	else
	59	*len = len_arg;
	60
	61	return 1;
	62	}
	63
54841ab5	64	static int do_spi_flash_probe(int argc, char * const argv[])
b6368467 HS	65	{
	66	unsigned int bus = 0;
	67	unsigned int cs;
	68	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	69	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	70	char *endp;
	71	struct spi_flash *new;
	72
	73	if (argc < 2)
8a07de03	74	return -1;
b6368467 HS	75
	76	cs = simple_strtoul(argv[1], &endp, 0);
	77	if (argv[1] == 0 \|\| (endp != 0 && *endp != ':'))
8a07de03	78	return -1;
b6368467 HS	79	if (*endp == ':') {
b6368467 HS	80	if (endp[1] == 0)
8a07de03	81	return -1;
b6368467 HS	82
	83	bus = cs;
	84	cs = simple_strtoul(endp + 1, &endp, 0);
	85	if (*endp != 0)
8a07de03	86	return -1;
b6368467 HS	87	}
	88
	89	if (argc >= 3) {
	90	speed = simple_strtoul(argv[2], &endp, 0);
	91	if (argv[2] == 0 \|\| endp != 0)
8a07de03	92	return -1;
b6368467 HS	93	}
b6368467 HS	94	if (argc >= 4) {
6e8d58d3	95	mode = simple_strtoul(argv[3], &endp, 16);
b6368467	96	if (argv[3] == 0 \|\| endp != 0)
8a07de03	97	return -1;
b6368467 HS	98	}
	99
	100	new = spi_flash_probe(bus, cs, speed, mode);
	101	if (!new) {
	102	printf("Failed to initialize SPI flash at %u:%u\n", bus, cs);
	103	return 1;
	104	}
	105
	106	if (flash)
	107	spi_flash_free(flash);
	108	flash = new;
	109
b6368467	110	return 0;
b6368467 HS	111	}
b6368467 HS	112
8d1af942 SG	113	/**
	114	* Write a block of data to SPI flash, first checking if it is different from
	115	* what is already there.
	116	*
	117	* If the data being written is the same, then *skipped is incremented by len.
	118	*
	119	* @param flash flash context pointer
	120	* @param offset flash offset to write
	121	* @param len number of bytes to write
	122	* @param buf buffer to write from
	123	* @param cmp_buf read buffer to use to compare data
	124	* @param skipped Count of skipped data (incremented by this function)
	125	* @return NULL if OK, else a string containing the stage which failed
	126	*/
	127	static const char spi_flash_update_block(struct spi_flash flash, u32 offset,
	128	size_t len, const char buf, char cmp_buf, size_t *skipped)
	129	{
a97f6efd	130	debug("offset=%#x, sector_size=%#x, len=%#zx\n",
8d1af942 SG	131	offset, flash->sector_size, len);
	132	if (spi_flash_read(flash, offset, len, cmp_buf))
	133	return "read";
	134	if (memcmp(cmp_buf, buf, len) == 0) {
a97f6efd	135	debug("Skip region %x size %zx: no change\n",
8d1af942 SG	136	offset, len);
	137	*skipped += len;
	138	return NULL;
	139	}
	140	if (spi_flash_erase(flash, offset, len))
	141	return "erase";
	142	if (spi_flash_write(flash, offset, len, buf))
	143	return "write";
	144	return NULL;
	145	}
	146
	147	/**
	148	* Update an area of SPI flash by erasing and writing any blocks which need
	149	* to change. Existing blocks with the correct data are left unchanged.
	150	*
	151	* @param flash flash context pointer
	152	* @param offset flash offset to write
	153	* @param len number of bytes to write
	154	* @param buf buffer to write from
	155	* @return 0 if ok, 1 on error
	156	*/
	157	static int spi_flash_update(struct spi_flash *flash, u32 offset,
	158	size_t len, const char *buf)
	159	{
	160	const char *err_oper = NULL;
	161	char *cmp_buf;
	162	const char *end = buf + len;
	163	size_t todo; /* number of bytes to do in this pass */
8e8a4bc2	164	size_t skipped = 0; /* statistics */
8d1af942 SG	165
	166	cmp_buf = malloc(flash->sector_size);
	167	if (cmp_buf) {
8e8a4bc2	168	for (; buf < end && !err_oper; buf += todo, offset += todo) {
8d1af942 SG	169	todo = min(end - buf, flash->sector_size);
	170	err_oper = spi_flash_update_block(flash, offset, todo,
	171	buf, cmp_buf, &skipped);
	172	}
	173	} else {
	174	err_oper = "malloc";
	175	}
	176	free(cmp_buf);
	177	if (err_oper) {
	178	printf("SPI flash failed in %s step\n", err_oper);
	179	return 1;
	180	}
	181	printf("%zu bytes written, %zu bytes skipped\n", len - skipped,
	182	skipped);
8e8a4bc2	183
8d1af942 SG	184	return 0;
	185	}
	186
54841ab5	187	static int do_spi_flash_read_write(int argc, char * const argv[])
b6368467 HS	188	{
	189	unsigned long addr;
	190	unsigned long offset;
	191	unsigned long len;
	192	void *buf;
	193	char *endp;
	194	int ret;
	195
	196	if (argc < 4)
8a07de03	197	return -1;
b6368467 HS	198
	199	addr = simple_strtoul(argv[1], &endp, 16);
	200	if (argv[1] == 0 \|\| endp != 0)
8a07de03	201	return -1;
b6368467 HS	202	offset = simple_strtoul(argv[2], &endp, 16);
b6368467 HS	203	if (argv[2] == 0 \|\| endp != 0)
8a07de03	204	return -1;
b6368467 HS	205	len = simple_strtoul(argv[3], &endp, 16);
b6368467 HS	206	if (argv[3] == 0 \|\| endp != 0)
8a07de03	207	return -1;
b6368467 HS	208
	209	buf = map_physmem(addr, len, MAP_WRBACK);
	210	if (!buf) {
	211	puts("Failed to map physical memory\n");
	212	return 1;
	213	}
	214
8d1af942 SG	215	if (strcmp(argv[0], "update") == 0)
	216	ret = spi_flash_update(flash, offset, len, buf);
	217	else if (strcmp(argv[0], "read") == 0)
b6368467 HS	218	ret = spi_flash_read(flash, offset, len, buf);
	219	else
	220	ret = spi_flash_write(flash, offset, len, buf);
	221
	222	unmap_physmem(buf, len);
	223
	224	if (ret) {
	225	printf("SPI flash %s failed\n", argv[0]);
	226	return 1;
	227	}
	228
	229	return 0;
b6368467 HS	230	}
b6368467 HS	231
54841ab5	232	static int do_spi_flash_erase(int argc, char * const argv[])
b6368467 HS	233	{
	234	unsigned long offset;
	235	unsigned long len;
	236	char *endp;
	237	int ret;
	238
	239	if (argc < 3)
8a07de03	240	return -1;
b6368467 HS	241
	242	offset = simple_strtoul(argv[1], &endp, 16);
	243	if (argv[1] == 0 \|\| endp != 0)
8a07de03	244	return -1;
334eb4b0 RR	245
	246	ret = sf_parse_len_arg(argv[2], &len);
	247	if (ret != 1)
8a07de03	248	return -1;
b6368467 HS	249
	250	ret = spi_flash_erase(flash, offset, len);
	251	if (ret) {
	252	printf("SPI flash %s failed\n", argv[0]);
	253	return 1;
	254	}
	255
	256	return 0;
b6368467 HS	257	}
b6368467 HS	258
54841ab5	259	static int do_spi_flash(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
b6368467 HS	260	{
b6368467 HS	261	const char *cmd;
8a07de03	262	int ret;
b6368467 HS	263
	264	/* need at least two arguments */
	265	if (argc < 2)
	266	goto usage;
	267
	268	cmd = argv[1];
8a07de03 MF	269	--argc;
8a07de03 MF	270	++argv;
b6368467	271
8a07de03 MF	272	if (strcmp(cmd, "probe") == 0) {
	273	ret = do_spi_flash_probe(argc, argv);
	274	goto done;
	275	}
b6368467 HS	276
	277	/* The remaining commands require a selected device */
	278	if (!flash) {
	279	puts("No SPI flash selected. Please run `sf probe'\n");
	280	return 1;
	281	}
	282
8d1af942 SG	283	if (strcmp(cmd, "read") == 0 \|\| strcmp(cmd, "write") == 0 \|\|
8d1af942 SG	284	strcmp(cmd, "update") == 0)
8a07de03 MF	285	ret = do_spi_flash_read_write(argc, argv);
	286	else if (strcmp(cmd, "erase") == 0)
	287	ret = do_spi_flash_erase(argc, argv);
	288	else
	289	ret = -1;
	290
	291	done:
	292	if (ret != -1)
	293	return ret;
b6368467 HS	294
b6368467 HS	295	usage:
47e26b1b	296	return cmd_usage(cmdtp);
b6368467 HS	297	}
	298
	299	U_BOOT_CMD(
	300	sf, 5, 1, do_spi_flash,
2fb2604d	301	"SPI flash sub-system",
b6368467 HS	302	"probe [bus:]cs [hz] [mode] - init flash device on given SPI bus\n"
	303	" and chip select\n"
	304	"sf read addr offset len - read `len' bytes starting at\n"
	305	" `offset' to memory at `addr'\n"
	306	"sf write addr offset len - write `len' bytes from memory\n"
	307	" at `addr' to flash at `offset'\n"
334eb4b0	308	"sf erase offset [+]len - erase `len' bytes from `offset'\n"
8d1af942 SG	309	" `+len' round up `len' to block size\n"
	310	"sf update addr offset len - erase and write `len' bytes from memory\n"
	311	" at `addr' to flash at `offset'"
a89c33db	312	);