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