• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * drivers/mtd/nand/nand_util.c
4  *
5  * Copyright (C) 2006 by Weiss-Electronic GmbH.
6  * All rights reserved.
7  *
8  * @author:	Guido Classen <clagix@gmail.com>
9  * @descr:	NAND Flash support
10  * @references: borrowed heavily from Linux mtd-utils code:
11  *		flash_eraseall.c by Arcom Control System Ltd
12  *		nandwrite.c by Steven J. Hill (sjhill@realitydiluted.com)
13  *			       and Thomas Gleixner (tglx@linutronix.de)
14  *
15  * Copyright (C) 2008 Nokia Corporation: drop_ffs() function by
16  * Artem Bityutskiy <dedekind1@gmail.com> from mtd-utils
17  *
18  * Copyright 2010 Freescale Semiconductor
19  */
20 
21 #include <common.h>
22 #include <command.h>
23 #include <watchdog.h>
24 #include <malloc.h>
25 #include <memalign.h>
26 #include <div64.h>
27 
28 #include <linux/errno.h>
29 #include <linux/mtd/mtd.h>
30 #include <nand.h>
31 #include <jffs2/jffs2.h>
32 
33 typedef struct erase_info	erase_info_t;
34 typedef struct mtd_info		mtd_info_t;
35 
36 /* support only for native endian JFFS2 */
37 #define cpu_to_je16(x) (x)
38 #define cpu_to_je32(x) (x)
39 
40 /**
41  * nand_erase_opts: - erase NAND flash with support for various options
42  *		      (jffs2 formatting)
43  *
44  * @param mtd		nand mtd instance to erase
45  * @param opts		options,  @see struct nand_erase_options
46  * @return		0 in case of success
47  *
48  * This code is ported from flash_eraseall.c from Linux mtd utils by
49  * Arcom Control System Ltd.
50  */
nand_erase_opts(struct mtd_info * mtd,const nand_erase_options_t * opts)51 int nand_erase_opts(struct mtd_info *mtd,
52 		    const nand_erase_options_t *opts)
53 {
54 	struct jffs2_unknown_node cleanmarker;
55 	erase_info_t erase;
56 	unsigned long erase_length, erased_length; /* in blocks */
57 	int result;
58 	int percent_complete = -1;
59 	const char *mtd_device = mtd->name;
60 	struct mtd_oob_ops oob_opts;
61 	struct nand_chip *chip = mtd_to_nand(mtd);
62 
63 	if ((opts->offset & (mtd->erasesize - 1)) != 0) {
64 		printf("Attempt to erase non block-aligned data\n");
65 		return -1;
66 	}
67 
68 	memset(&erase, 0, sizeof(erase));
69 	memset(&oob_opts, 0, sizeof(oob_opts));
70 
71 	erase.mtd = mtd;
72 	erase.len = mtd->erasesize;
73 	erase.addr = opts->offset;
74 	erase_length = lldiv(opts->length + mtd->erasesize - 1,
75 			     mtd->erasesize);
76 
77 	cleanmarker.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
78 	cleanmarker.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
79 	cleanmarker.totlen = cpu_to_je32(8);
80 
81 	/* scrub option allows to erase badblock. To prevent internal
82 	 * check from erase() method, set block check method to dummy
83 	 * and disable bad block table while erasing.
84 	 */
85 	if (opts->scrub) {
86 		erase.scrub = opts->scrub;
87 		/*
88 		 * We don't need the bad block table anymore...
89 		 * after scrub, there are no bad blocks left!
90 		 */
91 		if (chip->bbt) {
92 			kfree(chip->bbt);
93 		}
94 		chip->bbt = NULL;
95 		chip->options &= ~NAND_BBT_SCANNED;
96 	}
97 
98 	for (erased_length = 0;
99 	     erased_length < erase_length;
100 	     erase.addr += mtd->erasesize) {
101 
102 		WATCHDOG_RESET();
103 
104 		if (opts->lim && (erase.addr >= (opts->offset + opts->lim))) {
105 			puts("Size of erase exceeds limit\n");
106 			return -EFBIG;
107 		}
108 		if (!opts->scrub) {
109 			int ret = mtd_block_isbad(mtd, erase.addr);
110 			if (ret > 0) {
111 				if (!opts->quiet)
112 					printf("\rSkipping bad block at  "
113 					       "0x%08llx                 "
114 					       "                         \n",
115 					       erase.addr);
116 
117 				if (!opts->spread)
118 					erased_length++;
119 
120 				continue;
121 
122 			} else if (ret < 0) {
123 				printf("\n%s: MTD get bad block failed: %d\n",
124 				       mtd_device,
125 				       ret);
126 				return -1;
127 			}
128 		}
129 
130 		erased_length++;
131 
132 		result = mtd_erase(mtd, &erase);
133 		if (result != 0) {
134 			printf("\n%s: MTD Erase failure: %d\n",
135 			       mtd_device, result);
136 			continue;
137 		}
138 
139 		/* format for JFFS2 ? */
140 		if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) {
141 			struct mtd_oob_ops ops;
142 			ops.ooblen = 8;
143 			ops.datbuf = NULL;
144 			ops.oobbuf = (uint8_t *)&cleanmarker;
145 			ops.ooboffs = 0;
146 			ops.mode = MTD_OPS_AUTO_OOB;
147 
148 			result = mtd_write_oob(mtd, erase.addr, &ops);
149 			if (result != 0) {
150 				printf("\n%s: MTD writeoob failure: %d\n",
151 				       mtd_device, result);
152 				continue;
153 			}
154 		}
155 
156 		if (!opts->quiet) {
157 			unsigned long long n = erased_length * 100ULL;
158 			int percent;
159 
160 			do_div(n, erase_length);
161 			percent = (int)n;
162 
163 			/* output progress message only at whole percent
164 			 * steps to reduce the number of messages printed
165 			 * on (slow) serial consoles
166 			 */
167 			if (percent != percent_complete) {
168 				percent_complete = percent;
169 
170 				printf("\rErasing at 0x%llx -- %3d%% complete.",
171 				       erase.addr, percent);
172 
173 				if (opts->jffs2 && result == 0)
174 					printf(" Cleanmarker written at 0x%llx.",
175 					       erase.addr);
176 			}
177 		}
178 	}
179 	if (!opts->quiet)
180 		printf("\n");
181 
182 	return 0;
183 }
184 
185 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
186 
187 #define NAND_CMD_LOCK_TIGHT     0x2c
188 #define NAND_CMD_LOCK_STATUS    0x7a
189 
190 /******************************************************************************
191  * Support for locking / unlocking operations of some NAND devices
192  *****************************************************************************/
193 
194 /**
195  * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
196  *	      state
197  *
198  * @param mtd		nand mtd instance
199  * @param tight		bring device in lock tight mode
200  *
201  * @return		0 on success, -1 in case of error
202  *
203  * The lock / lock-tight command only applies to the whole chip. To get some
204  * parts of the chip lock and others unlocked use the following sequence:
205  *
206  * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
207  * - Call nand_unlock() once for each consecutive area to be unlocked
208  * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
209  *
210  *   If the device is in lock-tight state software can't change the
211  *   current active lock/unlock state of all pages. nand_lock() / nand_unlock()
212  *   calls will fail. It is only posible to leave lock-tight state by
213  *   an hardware signal (low pulse on _WP pin) or by power down.
214  */
nand_lock(struct mtd_info * mtd,int tight)215 int nand_lock(struct mtd_info *mtd, int tight)
216 {
217 	int ret = 0;
218 	int status;
219 	struct nand_chip *chip = mtd_to_nand(mtd);
220 
221 	/* select the NAND device */
222 	chip->select_chip(mtd, 0);
223 
224 	/* check the Lock Tight Status */
225 	chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, 0);
226 	if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
227 		printf("nand_lock: Device is locked tight!\n");
228 		ret = -1;
229 		goto out;
230 	}
231 
232 	chip->cmdfunc(mtd,
233 		      (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),
234 		      -1, -1);
235 
236 	/* call wait ready function */
237 	status = chip->waitfunc(mtd, chip);
238 
239 	/* see if device thinks it succeeded */
240 	if (status & 0x01) {
241 		ret = -1;
242 	}
243 
244  out:
245 	/* de-select the NAND device */
246 	chip->select_chip(mtd, -1);
247 	return ret;
248 }
249 
250 /**
251  * nand_get_lock_status: - query current lock state from one page of NAND
252  *			   flash
253  *
254  * @param mtd		nand mtd instance
255  * @param offset	page address to query (must be page-aligned!)
256  *
257  * @return		-1 in case of error
258  *			>0 lock status:
259  *			  bitfield with the following combinations:
260  *			  NAND_LOCK_STATUS_TIGHT: page in tight state
261  *			  NAND_LOCK_STATUS_UNLOCK: page unlocked
262  *
263  */
nand_get_lock_status(struct mtd_info * mtd,loff_t offset)264 int nand_get_lock_status(struct mtd_info *mtd, loff_t offset)
265 {
266 	int ret = 0;
267 	int chipnr;
268 	int page;
269 	struct nand_chip *chip = mtd_to_nand(mtd);
270 
271 	/* select the NAND device */
272 	chipnr = (int)(offset >> chip->chip_shift);
273 	chip->select_chip(mtd, chipnr);
274 
275 
276 	if ((offset & (mtd->writesize - 1)) != 0) {
277 		printf("nand_get_lock_status: "
278 			"Start address must be beginning of "
279 			"nand page!\n");
280 		ret = -1;
281 		goto out;
282 	}
283 
284 	/* check the Lock Status */
285 	page = (int)(offset >> chip->page_shift);
286 	chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
287 
288 	ret = chip->read_byte(mtd) & (NAND_LOCK_STATUS_TIGHT
289 					  | NAND_LOCK_STATUS_UNLOCK);
290 
291  out:
292 	/* de-select the NAND device */
293 	chip->select_chip(mtd, -1);
294 	return ret;
295 }
296 
297 /**
298  * nand_unlock: - Unlock area of NAND pages
299  *		  only one consecutive area can be unlocked at one time!
300  *
301  * @param mtd		nand mtd instance
302  * @param start		start byte address
303  * @param length	number of bytes to unlock (must be a multiple of
304  *			page size mtd->writesize)
305  * @param allexcept	if set, unlock everything not selected
306  *
307  * @return		0 on success, -1 in case of error
308  */
nand_unlock(struct mtd_info * mtd,loff_t start,size_t length,int allexcept)309 int nand_unlock(struct mtd_info *mtd, loff_t start, size_t length,
310 	int allexcept)
311 {
312 	int ret = 0;
313 	int chipnr;
314 	int status;
315 	int page;
316 	struct nand_chip *chip = mtd_to_nand(mtd);
317 
318 	debug("nand_unlock%s: start: %08llx, length: %zd!\n",
319 		allexcept ? " (allexcept)" : "", start, length);
320 
321 	/* select the NAND device */
322 	chipnr = (int)(start >> chip->chip_shift);
323 	chip->select_chip(mtd, chipnr);
324 
325 	/* check the WP bit */
326 	chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
327 	if (!(chip->read_byte(mtd) & NAND_STATUS_WP)) {
328 		printf("nand_unlock: Device is write protected!\n");
329 		ret = -1;
330 		goto out;
331 	}
332 
333 	/* check the Lock Tight Status */
334 	page = (int)(start >> chip->page_shift);
335 	chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
336 	if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) {
337 		printf("nand_unlock: Device is locked tight!\n");
338 		ret = -1;
339 		goto out;
340 	}
341 
342 	if ((start & (mtd->erasesize - 1)) != 0) {
343 		printf("nand_unlock: Start address must be beginning of "
344 			"nand block!\n");
345 		ret = -1;
346 		goto out;
347 	}
348 
349 	if (length == 0 || (length & (mtd->erasesize - 1)) != 0) {
350 		printf("nand_unlock: Length must be a multiple of nand block "
351 			"size %08x!\n", mtd->erasesize);
352 		ret = -1;
353 		goto out;
354 	}
355 
356 	/*
357 	 * Set length so that the last address is set to the
358 	 * starting address of the last block
359 	 */
360 	length -= mtd->erasesize;
361 
362 	/* submit address of first page to unlock */
363 	chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask);
364 
365 	/* submit ADDRESS of LAST page to unlock */
366 	page += (int)(length >> chip->page_shift);
367 
368 	/*
369 	 * Page addresses for unlocking are supposed to be block-aligned.
370 	 * At least some NAND chips use the low bit to indicate that the
371 	 * page range should be inverted.
372 	 */
373 	if (allexcept)
374 		page |= 1;
375 
376 	chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, page & chip->pagemask);
377 
378 	/* call wait ready function */
379 	status = chip->waitfunc(mtd, chip);
380 	/* see if device thinks it succeeded */
381 	if (status & 0x01) {
382 		/* there was an error */
383 		ret = -1;
384 		goto out;
385 	}
386 
387  out:
388 	/* de-select the NAND device */
389 	chip->select_chip(mtd, -1);
390 	return ret;
391 }
392 #endif
393 
394 /**
395  * check_skip_len
396  *
397  * Check if there are any bad blocks, and whether length including bad
398  * blocks fits into device
399  *
400  * @param mtd nand mtd instance
401  * @param offset offset in flash
402  * @param length image length
403  * @param used length of flash needed for the requested length
404  * @return 0 if the image fits and there are no bad blocks
405  *         1 if the image fits, but there are bad blocks
406  *        -1 if the image does not fit
407  */
check_skip_len(struct mtd_info * mtd,loff_t offset,size_t length,size_t * used)408 static int check_skip_len(struct mtd_info *mtd, loff_t offset, size_t length,
409 			  size_t *used)
410 {
411 	size_t len_excl_bad = 0;
412 	int ret = 0;
413 
414 	while (len_excl_bad < length) {
415 		size_t block_len, block_off;
416 		loff_t block_start;
417 
418 		if (offset >= mtd->size)
419 			return -1;
420 
421 		block_start = offset & ~(loff_t)(mtd->erasesize - 1);
422 		block_off = offset & (mtd->erasesize - 1);
423 		block_len = mtd->erasesize - block_off;
424 
425 		if (!nand_block_isbad(mtd, block_start))
426 			len_excl_bad += block_len;
427 		else
428 			ret = 1;
429 
430 		offset += block_len;
431 		*used += block_len;
432 	}
433 
434 	/* If the length is not a multiple of block_len, adjust. */
435 	if (len_excl_bad > length)
436 		*used -= (len_excl_bad - length);
437 
438 	return ret;
439 }
440 
441 #ifdef CONFIG_CMD_NAND_TRIMFFS
drop_ffs(const struct mtd_info * mtd,const u_char * buf,const size_t * len)442 static size_t drop_ffs(const struct mtd_info *mtd, const u_char *buf,
443 			const size_t *len)
444 {
445 	size_t l = *len;
446 	ssize_t i;
447 
448 	for (i = l - 1; i >= 0; i--)
449 		if (buf[i] != 0xFF)
450 			break;
451 
452 	/* The resulting length must be aligned to the minimum flash I/O size */
453 	l = i + 1;
454 	l = (l + mtd->writesize - 1) / mtd->writesize;
455 	l *=  mtd->writesize;
456 
457 	/*
458 	 * since the input length may be unaligned, prevent access past the end
459 	 * of the buffer
460 	 */
461 	return min(l, *len);
462 }
463 #endif
464 
465 /**
466  * nand_verify_page_oob:
467  *
468  * Verify a page of NAND flash, including the OOB.
469  * Reads page of NAND and verifies the contents and OOB against the
470  * values in ops.
471  *
472  * @param mtd		nand mtd instance
473  * @param ops		MTD operations, including data to verify
474  * @param ofs		offset in flash
475  * @return		0 in case of success
476  */
nand_verify_page_oob(struct mtd_info * mtd,struct mtd_oob_ops * ops,loff_t ofs)477 int nand_verify_page_oob(struct mtd_info *mtd, struct mtd_oob_ops *ops,
478 			 loff_t ofs)
479 {
480 	int rval;
481 	struct mtd_oob_ops vops;
482 	size_t verlen = mtd->writesize + mtd->oobsize;
483 
484 	memcpy(&vops, ops, sizeof(vops));
485 
486 	vops.datbuf = memalign(ARCH_DMA_MINALIGN, verlen);
487 
488 	if (!vops.datbuf)
489 		return -ENOMEM;
490 
491 	vops.oobbuf = vops.datbuf + mtd->writesize;
492 
493 	rval = mtd_read_oob(mtd, ofs, &vops);
494 	if (!rval)
495 		rval = memcmp(ops->datbuf, vops.datbuf, vops.len);
496 	if (!rval)
497 		rval = memcmp(ops->oobbuf, vops.oobbuf, vops.ooblen);
498 
499 	free(vops.datbuf);
500 
501 	return rval ? -EIO : 0;
502 }
503 
504 /**
505  * nand_verify:
506  *
507  * Verify a region of NAND flash.
508  * Reads NAND in page-sized chunks and verifies the contents against
509  * the contents of a buffer.  The offset into the NAND must be
510  * page-aligned, and the function doesn't handle skipping bad blocks.
511  *
512  * @param mtd		nand mtd instance
513  * @param ofs		offset in flash
514  * @param len		buffer length
515  * @param buf		buffer to read from
516  * @return		0 in case of success
517  */
nand_verify(struct mtd_info * mtd,loff_t ofs,size_t len,u_char * buf)518 int nand_verify(struct mtd_info *mtd, loff_t ofs, size_t len, u_char *buf)
519 {
520 	int rval = 0;
521 	size_t verofs;
522 	size_t verlen = mtd->writesize;
523 	uint8_t *verbuf = memalign(ARCH_DMA_MINALIGN, verlen);
524 
525 	if (!verbuf)
526 		return -ENOMEM;
527 
528 	/* Read the NAND back in page-size groups to limit malloc size */
529 	for (verofs = ofs; verofs < ofs + len;
530 	     verofs += verlen, buf += verlen) {
531 		verlen = min(mtd->writesize, (uint32_t)(ofs + len - verofs));
532 		rval = nand_read(mtd, verofs, &verlen, verbuf);
533 		if (!rval || (rval == -EUCLEAN))
534 			rval = memcmp(buf, verbuf, verlen);
535 
536 		if (rval)
537 			break;
538 	}
539 
540 	free(verbuf);
541 
542 	return rval ? -EIO : 0;
543 }
544 
545 
546 
547 /**
548  * nand_write_skip_bad:
549  *
550  * Write image to NAND flash.
551  * Blocks that are marked bad are skipped and the is written to the next
552  * block instead as long as the image is short enough to fit even after
553  * skipping the bad blocks.  Due to bad blocks we may not be able to
554  * perform the requested write.  In the case where the write would
555  * extend beyond the end of the NAND device, both length and actual (if
556  * not NULL) are set to 0.  In the case where the write would extend
557  * beyond the limit we are passed, length is set to 0 and actual is set
558  * to the required length.
559  *
560  * @param mtd		nand mtd instance
561  * @param offset	offset in flash
562  * @param length	buffer length
563  * @param actual	set to size required to write length worth of
564  *			buffer or 0 on error, if not NULL
565  * @param lim		maximum size that actual may be in order to not
566  *			exceed the buffer
567  * @param buffer        buffer to read from
568  * @param flags		flags modifying the behaviour of the write to NAND
569  * @return		0 in case of success
570  */
nand_write_skip_bad(struct mtd_info * mtd,loff_t offset,size_t * length,size_t * actual,loff_t lim,u_char * buffer,int flags)571 int nand_write_skip_bad(struct mtd_info *mtd, loff_t offset, size_t *length,
572 			size_t *actual, loff_t lim, u_char *buffer, int flags)
573 {
574 	int rval = 0, blocksize;
575 	size_t left_to_write = *length;
576 	size_t used_for_write = 0;
577 	u_char *p_buffer = buffer;
578 	int need_skip;
579 
580 	if (actual)
581 		*actual = 0;
582 
583 	blocksize = mtd->erasesize;
584 
585 	/*
586 	 * nand_write() handles unaligned, partial page writes.
587 	 *
588 	 * We allow length to be unaligned, for convenience in
589 	 * using the $filesize variable.
590 	 *
591 	 * However, starting at an unaligned offset makes the
592 	 * semantics of bad block skipping ambiguous (really,
593 	 * you should only start a block skipping access at a
594 	 * partition boundary).  So don't try to handle that.
595 	 */
596 	if ((offset & (mtd->writesize - 1)) != 0) {
597 		printf("Attempt to write non page-aligned data\n");
598 		*length = 0;
599 		return -EINVAL;
600 	}
601 
602 	need_skip = check_skip_len(mtd, offset, *length, &used_for_write);
603 
604 	if (actual)
605 		*actual = used_for_write;
606 
607 	if (need_skip < 0) {
608 		printf("Attempt to write outside the flash area\n");
609 		*length = 0;
610 		return -EINVAL;
611 	}
612 
613 	if (used_for_write > lim) {
614 		puts("Size of write exceeds partition or device limit\n");
615 		*length = 0;
616 		return -EFBIG;
617 	}
618 
619 	if (!need_skip && !(flags & WITH_DROP_FFS)) {
620 		rval = nand_write(mtd, offset, length, buffer);
621 
622 		if ((flags & WITH_WR_VERIFY) && !rval)
623 			rval = nand_verify(mtd, offset, *length, buffer);
624 
625 		if (rval == 0)
626 			return 0;
627 
628 		*length = 0;
629 		printf("NAND write to offset %llx failed %d\n",
630 			offset, rval);
631 		return rval;
632 	}
633 
634 	while (left_to_write > 0) {
635 		size_t block_offset = offset & (mtd->erasesize - 1);
636 		size_t write_size, truncated_write_size;
637 
638 		WATCHDOG_RESET();
639 
640 		if (nand_block_isbad(mtd, offset & ~(mtd->erasesize - 1))) {
641 			printf("Skip bad block 0x%08llx\n",
642 				offset & ~(mtd->erasesize - 1));
643 			offset += mtd->erasesize - block_offset;
644 			continue;
645 		}
646 
647 		if (left_to_write < (blocksize - block_offset))
648 			write_size = left_to_write;
649 		else
650 			write_size = blocksize - block_offset;
651 
652 		truncated_write_size = write_size;
653 #ifdef CONFIG_CMD_NAND_TRIMFFS
654 		if (flags & WITH_DROP_FFS)
655 			truncated_write_size = drop_ffs(mtd, p_buffer,
656 					&write_size);
657 #endif
658 
659 		rval = nand_write(mtd, offset, &truncated_write_size,
660 				p_buffer);
661 
662 		if ((flags & WITH_WR_VERIFY) && !rval)
663 			rval = nand_verify(mtd, offset,
664 				truncated_write_size, p_buffer);
665 
666 		offset += write_size;
667 		p_buffer += write_size;
668 
669 		if (rval != 0) {
670 			printf("NAND write to offset %llx failed %d\n",
671 				offset, rval);
672 			*length -= left_to_write;
673 			return rval;
674 		}
675 
676 		left_to_write -= write_size;
677 	}
678 
679 	return 0;
680 }
681 
682 /**
683  * nand_read_skip_bad:
684  *
685  * Read image from NAND flash.
686  * Blocks that are marked bad are skipped and the next block is read
687  * instead as long as the image is short enough to fit even after
688  * skipping the bad blocks.  Due to bad blocks we may not be able to
689  * perform the requested read.  In the case where the read would extend
690  * beyond the end of the NAND device, both length and actual (if not
691  * NULL) are set to 0.  In the case where the read would extend beyond
692  * the limit we are passed, length is set to 0 and actual is set to the
693  * required length.
694  *
695  * @param mtd nand mtd instance
696  * @param offset offset in flash
697  * @param length buffer length, on return holds number of read bytes
698  * @param actual set to size required to read length worth of buffer or 0
699  * on error, if not NULL
700  * @param lim maximum size that actual may be in order to not exceed the
701  * buffer
702  * @param buffer buffer to write to
703  * @return 0 in case of success
704  */
nand_read_skip_bad(struct mtd_info * mtd,loff_t offset,size_t * length,size_t * actual,loff_t lim,u_char * buffer)705 int nand_read_skip_bad(struct mtd_info *mtd, loff_t offset, size_t *length,
706 		       size_t *actual, loff_t lim, u_char *buffer)
707 {
708 	int rval;
709 	size_t left_to_read = *length;
710 	size_t used_for_read = 0;
711 	u_char *p_buffer = buffer;
712 	int need_skip;
713 
714 	if ((offset & (mtd->writesize - 1)) != 0) {
715 		printf("Attempt to read non page-aligned data\n");
716 		*length = 0;
717 		if (actual)
718 			*actual = 0;
719 		return -EINVAL;
720 	}
721 
722 	need_skip = check_skip_len(mtd, offset, *length, &used_for_read);
723 
724 	if (actual)
725 		*actual = used_for_read;
726 
727 	if (need_skip < 0) {
728 		printf("Attempt to read outside the flash area\n");
729 		*length = 0;
730 		return -EINVAL;
731 	}
732 
733 	if (used_for_read > lim) {
734 		puts("Size of read exceeds partition or device limit\n");
735 		*length = 0;
736 		return -EFBIG;
737 	}
738 
739 	if (!need_skip) {
740 		rval = nand_read(mtd, offset, length, buffer);
741 		if (!rval || rval == -EUCLEAN)
742 			return 0;
743 
744 		*length = 0;
745 		printf("NAND read from offset %llx failed %d\n",
746 			offset, rval);
747 		return rval;
748 	}
749 
750 	while (left_to_read > 0) {
751 		size_t block_offset = offset & (mtd->erasesize - 1);
752 		size_t read_length;
753 
754 		WATCHDOG_RESET();
755 
756 		if (nand_block_isbad(mtd, offset & ~(mtd->erasesize - 1))) {
757 			printf("Skipping bad block 0x%08llx\n",
758 				offset & ~(mtd->erasesize - 1));
759 			offset += mtd->erasesize - block_offset;
760 			continue;
761 		}
762 
763 		if (left_to_read < (mtd->erasesize - block_offset))
764 			read_length = left_to_read;
765 		else
766 			read_length = mtd->erasesize - block_offset;
767 
768 		rval = nand_read(mtd, offset, &read_length, p_buffer);
769 		if (rval && rval != -EUCLEAN) {
770 			printf("NAND read from offset %llx failed %d\n",
771 				offset, rval);
772 			*length -= left_to_read;
773 			return rval;
774 		}
775 
776 		left_to_read -= read_length;
777 		offset       += read_length;
778 		p_buffer     += read_length;
779 	}
780 
781 	return 0;
782 }
783 
784 #ifdef CONFIG_CMD_NAND_TORTURE
785 
786 /**
787  * check_pattern:
788  *
789  * Check if buffer contains only a certain byte pattern.
790  *
791  * @param buf buffer to check
792  * @param patt the pattern to check
793  * @param size buffer size in bytes
794  * @return 1 if there are only patt bytes in buf
795  *         0 if something else was found
796  */
check_pattern(const u_char * buf,u_char patt,int size)797 static int check_pattern(const u_char *buf, u_char patt, int size)
798 {
799 	int i;
800 
801 	for (i = 0; i < size; i++)
802 		if (buf[i] != patt)
803 			return 0;
804 	return 1;
805 }
806 
807 /**
808  * nand_torture:
809  *
810  * Torture a block of NAND flash.
811  * This is useful to determine if a block that caused a write error is still
812  * good or should be marked as bad.
813  *
814  * @param mtd nand mtd instance
815  * @param offset offset in flash
816  * @return 0 if the block is still good
817  */
nand_torture(struct mtd_info * mtd,loff_t offset)818 int nand_torture(struct mtd_info *mtd, loff_t offset)
819 {
820 	u_char patterns[] = {0xa5, 0x5a, 0x00};
821 	struct erase_info instr = {
822 		.mtd = mtd,
823 		.addr = offset,
824 		.len = mtd->erasesize,
825 	};
826 	size_t retlen;
827 	int err, ret = -1, i, patt_count;
828 	u_char *buf;
829 
830 	if ((offset & (mtd->erasesize - 1)) != 0) {
831 		puts("Attempt to torture a block at a non block-aligned offset\n");
832 		return -EINVAL;
833 	}
834 
835 	if (offset + mtd->erasesize > mtd->size) {
836 		puts("Attempt to torture a block outside the flash area\n");
837 		return -EINVAL;
838 	}
839 
840 	patt_count = ARRAY_SIZE(patterns);
841 
842 	buf = malloc_cache_aligned(mtd->erasesize);
843 	if (buf == NULL) {
844 		puts("Out of memory for erase block buffer\n");
845 		return -ENOMEM;
846 	}
847 
848 	for (i = 0; i < patt_count; i++) {
849 		err = mtd_erase(mtd, &instr);
850 		if (err) {
851 			printf("%s: erase() failed for block at 0x%llx: %d\n",
852 				mtd->name, instr.addr, err);
853 			goto out;
854 		}
855 
856 		/* Make sure the block contains only 0xff bytes */
857 		err = mtd_read(mtd, offset, mtd->erasesize, &retlen, buf);
858 		if ((err && err != -EUCLEAN) || retlen != mtd->erasesize) {
859 			printf("%s: read() failed for block at 0x%llx: %d\n",
860 				mtd->name, instr.addr, err);
861 			goto out;
862 		}
863 
864 		err = check_pattern(buf, 0xff, mtd->erasesize);
865 		if (!err) {
866 			printf("Erased block at 0x%llx, but a non-0xff byte was found\n",
867 				offset);
868 			ret = -EIO;
869 			goto out;
870 		}
871 
872 		/* Write a pattern and check it */
873 		memset(buf, patterns[i], mtd->erasesize);
874 		err = mtd_write(mtd, offset, mtd->erasesize, &retlen, buf);
875 		if (err || retlen != mtd->erasesize) {
876 			printf("%s: write() failed for block at 0x%llx: %d\n",
877 				mtd->name, instr.addr, err);
878 			goto out;
879 		}
880 
881 		err = mtd_read(mtd, offset, mtd->erasesize, &retlen, buf);
882 		if ((err && err != -EUCLEAN) || retlen != mtd->erasesize) {
883 			printf("%s: read() failed for block at 0x%llx: %d\n",
884 				mtd->name, instr.addr, err);
885 			goto out;
886 		}
887 
888 		err = check_pattern(buf, patterns[i], mtd->erasesize);
889 		if (!err) {
890 			printf("Pattern 0x%.2x checking failed for block at "
891 					"0x%llx\n", patterns[i], offset);
892 			ret = -EIO;
893 			goto out;
894 		}
895 	}
896 
897 	ret = 0;
898 
899 out:
900 	free(buf);
901 	return ret;
902 }
903 
904 #endif
905