Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 1 | /* |
Marcel Ziswiler | aea6856 | 2007-12-30 03:30:46 +0100 | [diff] [blame] | 2 | * drivers/mtd/nand/nand_util.c |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2006 by Weiss-Electronic GmbH. |
| 5 | * All rights reserved. |
| 6 | * |
| 7 | * @author: Guido Classen <clagix@gmail.com> |
| 8 | * @descr: NAND Flash support |
| 9 | * @references: borrowed heavily from Linux mtd-utils code: |
| 10 | * flash_eraseall.c by Arcom Control System Ltd |
| 11 | * nandwrite.c by Steven J. Hill (sjhill@realitydiluted.com) |
| 12 | * and Thomas Gleixner (tglx@linutronix.de) |
| 13 | * |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 14 | * Copyright (C) 2008 Nokia Corporation: drop_ffs() function by |
| 15 | * Artem Bityutskiy <dedekind1@gmail.com> from mtd-utils |
| 16 | * |
Tom Rini | b7bef6a | 2013-10-31 09:24:00 -0400 | [diff] [blame] | 17 | * Copyright 2010 Freescale Semiconductor |
| 18 | * |
| 19 | * SPDX-License-Identifier: GPL-2.0 |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 20 | */ |
| 21 | |
| 22 | #include <common.h> |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 23 | #include <command.h> |
| 24 | #include <watchdog.h> |
| 25 | #include <malloc.h> |
Dirk Behme | 32d1f76 | 2007-08-02 17:42:08 +0200 | [diff] [blame] | 26 | #include <div64.h> |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 27 | |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 28 | #include <asm/errno.h> |
| 29 | #include <linux/mtd/mtd.h> |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 30 | #include <nand.h> |
| 31 | #include <jffs2/jffs2.h> |
| 32 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 33 | typedef struct erase_info erase_info_t; |
| 34 | typedef struct mtd_info mtd_info_t; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 35 | |
| 36 | /* support only for native endian JFFS2 */ |
| 37 | #define cpu_to_je16(x) (x) |
| 38 | #define cpu_to_je32(x) (x) |
| 39 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 40 | /** |
| 41 | * nand_erase_opts: - erase NAND flash with support for various options |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 42 | * (jffs2 formatting) |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 43 | * |
| 44 | * @param meminfo NAND device 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 | */ |
| 51 | int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts) |
| 52 | { |
| 53 | struct jffs2_unknown_node cleanmarker; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 54 | erase_info_t erase; |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 55 | unsigned long erase_length, erased_length; /* in blocks */ |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 56 | int result; |
| 57 | int percent_complete = -1; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 58 | const char *mtd_device = meminfo->name; |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 59 | struct mtd_oob_ops oob_opts; |
| 60 | struct nand_chip *chip = meminfo->priv; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 61 | |
Benoît Thébaudeau | ad5d6ee | 2012-11-05 10:16:15 +0000 | [diff] [blame] | 62 | if ((opts->offset & (meminfo->erasesize - 1)) != 0) { |
| 63 | printf("Attempt to erase non block-aligned data\n"); |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 64 | return -1; |
| 65 | } |
| 66 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 67 | memset(&erase, 0, sizeof(erase)); |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 68 | memset(&oob_opts, 0, sizeof(oob_opts)); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 69 | |
| 70 | erase.mtd = meminfo; |
| 71 | erase.len = meminfo->erasesize; |
Stefan Roese | 198b23e | 2006-10-28 15:55:52 +0200 | [diff] [blame] | 72 | erase.addr = opts->offset; |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 73 | erase_length = lldiv(opts->length + meminfo->erasesize - 1, |
| 74 | meminfo->erasesize); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 75 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 76 | cleanmarker.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
| 77 | cleanmarker.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER); |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 78 | cleanmarker.totlen = cpu_to_je32(8); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 79 | |
| 80 | /* scrub option allows to erase badblock. To prevent internal |
| 81 | * check from erase() method, set block check method to dummy |
| 82 | * and disable bad block table while erasing. |
| 83 | */ |
| 84 | if (opts->scrub) { |
Marek Vasut | 971d9a1 | 2011-09-12 06:04:06 +0200 | [diff] [blame] | 85 | erase.scrub = opts->scrub; |
| 86 | /* |
| 87 | * We don't need the bad block table anymore... |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 88 | * after scrub, there are no bad blocks left! |
| 89 | */ |
Marek Vasut | 971d9a1 | 2011-09-12 06:04:06 +0200 | [diff] [blame] | 90 | if (chip->bbt) { |
| 91 | kfree(chip->bbt); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 92 | } |
Marek Vasut | 971d9a1 | 2011-09-12 06:04:06 +0200 | [diff] [blame] | 93 | chip->bbt = NULL; |
Masahiro Yamada | 8d10054 | 2014-12-26 22:20:58 +0900 | [diff] [blame] | 94 | chip->options &= ~NAND_BBT_SCANNED; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 95 | } |
| 96 | |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 97 | for (erased_length = 0; |
| 98 | erased_length < erase_length; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 99 | erase.addr += meminfo->erasesize) { |
William Juul | b76ec38 | 2007-11-08 10:39:53 +0100 | [diff] [blame] | 100 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 101 | WATCHDOG_RESET(); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 102 | |
Heiko Schocher | 0ae98b4 | 2013-06-24 18:50:40 +0200 | [diff] [blame] | 103 | if (opts->lim && (erase.addr >= (opts->offset + opts->lim))) { |
| 104 | puts("Size of erase exceeds limit\n"); |
| 105 | return -EFBIG; |
| 106 | } |
Masahiro Yamada | 7580d58 | 2013-07-12 10:53:37 +0900 | [diff] [blame] | 107 | if (!opts->scrub) { |
Sergey Lapin | 3a38a55 | 2013-01-14 03:46:50 +0000 | [diff] [blame] | 108 | int ret = mtd_block_isbad(meminfo, erase.addr); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 109 | if (ret > 0) { |
| 110 | if (!opts->quiet) |
| 111 | printf("\rSkipping bad block at " |
Stefan Roese | 586b3a6 | 2009-05-11 16:03:55 +0200 | [diff] [blame] | 112 | "0x%08llx " |
Wolfgang Denk | d5cf1a4 | 2006-10-12 11:43:47 +0200 | [diff] [blame] | 113 | " \n", |
| 114 | erase.addr); |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 115 | |
| 116 | if (!opts->spread) |
| 117 | erased_length++; |
| 118 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 119 | continue; |
| 120 | |
| 121 | } else if (ret < 0) { |
| 122 | printf("\n%s: MTD get bad block failed: %d\n", |
| 123 | mtd_device, |
| 124 | ret); |
| 125 | return -1; |
| 126 | } |
| 127 | } |
| 128 | |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 129 | erased_length++; |
| 130 | |
Sergey Lapin | 3a38a55 | 2013-01-14 03:46:50 +0000 | [diff] [blame] | 131 | result = mtd_erase(meminfo, &erase); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 132 | if (result != 0) { |
| 133 | printf("\n%s: MTD Erase failure: %d\n", |
| 134 | mtd_device, result); |
| 135 | continue; |
| 136 | } |
| 137 | |
| 138 | /* format for JFFS2 ? */ |
Scott Wood | d50ad35 | 2008-10-29 14:20:26 -0500 | [diff] [blame] | 139 | if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) { |
Sergey Lapin | 3a38a55 | 2013-01-14 03:46:50 +0000 | [diff] [blame] | 140 | struct mtd_oob_ops ops; |
| 141 | ops.ooblen = 8; |
| 142 | ops.datbuf = NULL; |
| 143 | ops.oobbuf = (uint8_t *)&cleanmarker; |
| 144 | ops.ooboffs = 0; |
| 145 | ops.mode = MTD_OPS_AUTO_OOB; |
William Juul | b76ec38 | 2007-11-08 10:39:53 +0100 | [diff] [blame] | 146 | |
Sergey Lapin | 3a38a55 | 2013-01-14 03:46:50 +0000 | [diff] [blame] | 147 | result = mtd_write_oob(meminfo, |
Wolfgang Denk | ec7fbf5 | 2013-10-04 17:43:24 +0200 | [diff] [blame] | 148 | erase.addr, |
| 149 | &ops); |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 150 | if (result != 0) { |
| 151 | printf("\n%s: MTD writeoob failure: %d\n", |
Scott Wood | d50ad35 | 2008-10-29 14:20:26 -0500 | [diff] [blame] | 152 | mtd_device, result); |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 153 | continue; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 154 | } |
| 155 | } |
| 156 | |
| 157 | if (!opts->quiet) { |
Scott Wood | 1b5cd51 | 2010-08-25 14:43:29 -0500 | [diff] [blame] | 158 | unsigned long long n = erased_length * 100ULL; |
Matthias Fuchs | 82714b9 | 2007-09-11 17:04:00 +0200 | [diff] [blame] | 159 | int percent; |
| 160 | |
| 161 | do_div(n, erase_length); |
| 162 | percent = (int)n; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 163 | |
| 164 | /* output progress message only at whole percent |
| 165 | * steps to reduce the number of messages printed |
| 166 | * on (slow) serial consoles |
| 167 | */ |
| 168 | if (percent != percent_complete) { |
| 169 | percent_complete = percent; |
| 170 | |
Stefan Roese | 586b3a6 | 2009-05-11 16:03:55 +0200 | [diff] [blame] | 171 | printf("\rErasing at 0x%llx -- %3d%% complete.", |
Scott Wood | d50ad35 | 2008-10-29 14:20:26 -0500 | [diff] [blame] | 172 | erase.addr, percent); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 173 | |
| 174 | if (opts->jffs2 && result == 0) |
Stefan Roese | 586b3a6 | 2009-05-11 16:03:55 +0200 | [diff] [blame] | 175 | printf(" Cleanmarker written at 0x%llx.", |
Scott Wood | d50ad35 | 2008-10-29 14:20:26 -0500 | [diff] [blame] | 176 | erase.addr); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 177 | } |
| 178 | } |
| 179 | } |
| 180 | if (!opts->quiet) |
| 181 | printf("\n"); |
| 182 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 183 | return 0; |
| 184 | } |
| 185 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 186 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
| 187 | |
Heiko Schocher | f5895d1 | 2014-06-24 10:10:04 +0200 | [diff] [blame] | 188 | #define NAND_CMD_LOCK_TIGHT 0x2c |
| 189 | #define NAND_CMD_LOCK_STATUS 0x7a |
| 190 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 191 | /****************************************************************************** |
| 192 | * Support for locking / unlocking operations of some NAND devices |
| 193 | *****************************************************************************/ |
| 194 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 195 | /** |
| 196 | * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT |
| 197 | * state |
| 198 | * |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 199 | * @param mtd nand mtd instance |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 200 | * @param tight bring device in lock tight mode |
| 201 | * |
| 202 | * @return 0 on success, -1 in case of error |
| 203 | * |
| 204 | * The lock / lock-tight command only applies to the whole chip. To get some |
| 205 | * parts of the chip lock and others unlocked use the following sequence: |
| 206 | * |
| 207 | * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin) |
| 208 | * - Call nand_unlock() once for each consecutive area to be unlocked |
| 209 | * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1) |
| 210 | * |
| 211 | * If the device is in lock-tight state software can't change the |
| 212 | * current active lock/unlock state of all pages. nand_lock() / nand_unlock() |
| 213 | * calls will fail. It is only posible to leave lock-tight state by |
| 214 | * an hardware signal (low pulse on _WP pin) or by power down. |
| 215 | */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 216 | int nand_lock(struct mtd_info *mtd, int tight) |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 217 | { |
| 218 | int ret = 0; |
| 219 | int status; |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 220 | struct nand_chip *chip = mtd->priv; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 221 | |
| 222 | /* select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 223 | chip->select_chip(mtd, 0); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 224 | |
Joe Hershberger | 8b177d4 | 2013-02-08 09:27:19 +0000 | [diff] [blame] | 225 | /* check the Lock Tight Status */ |
| 226 | chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, 0); |
| 227 | if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) { |
| 228 | printf("nand_lock: Device is locked tight!\n"); |
| 229 | ret = -1; |
| 230 | goto out; |
| 231 | } |
| 232 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 233 | chip->cmdfunc(mtd, |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 234 | (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK), |
| 235 | -1, -1); |
| 236 | |
| 237 | /* call wait ready function */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 238 | status = chip->waitfunc(mtd, chip); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 239 | |
| 240 | /* see if device thinks it succeeded */ |
| 241 | if (status & 0x01) { |
| 242 | ret = -1; |
| 243 | } |
| 244 | |
Joe Hershberger | 8b177d4 | 2013-02-08 09:27:19 +0000 | [diff] [blame] | 245 | out: |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 246 | /* de-select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 247 | chip->select_chip(mtd, -1); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 248 | return ret; |
| 249 | } |
| 250 | |
| 251 | /** |
| 252 | * nand_get_lock_status: - query current lock state from one page of NAND |
| 253 | * flash |
| 254 | * |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 255 | * @param mtd nand mtd instance |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 256 | * @param offset page address to query (must be page-aligned!) |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 257 | * |
| 258 | * @return -1 in case of error |
| 259 | * >0 lock status: |
| 260 | * bitfield with the following combinations: |
| 261 | * NAND_LOCK_STATUS_TIGHT: page in tight state |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 262 | * NAND_LOCK_STATUS_UNLOCK: page unlocked |
| 263 | * |
| 264 | */ |
Jean-Christophe PLAGNIOL-VILLARD | 2511ba0 | 2009-05-16 14:27:40 +0200 | [diff] [blame] | 265 | int nand_get_lock_status(struct mtd_info *mtd, loff_t offset) |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 266 | { |
| 267 | int ret = 0; |
| 268 | int chipnr; |
| 269 | int page; |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 270 | struct nand_chip *chip = mtd->priv; |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 271 | |
| 272 | /* select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 273 | chipnr = (int)(offset >> chip->chip_shift); |
| 274 | chip->select_chip(mtd, chipnr); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 275 | |
| 276 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 277 | if ((offset & (mtd->writesize - 1)) != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 278 | printf("nand_get_lock_status: " |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 279 | "Start address must be beginning of " |
| 280 | "nand page!\n"); |
| 281 | ret = -1; |
| 282 | goto out; |
| 283 | } |
| 284 | |
| 285 | /* check the Lock Status */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 286 | page = (int)(offset >> chip->page_shift); |
| 287 | chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 288 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 289 | ret = chip->read_byte(mtd) & (NAND_LOCK_STATUS_TIGHT |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 290 | | NAND_LOCK_STATUS_UNLOCK); |
| 291 | |
| 292 | out: |
| 293 | /* de-select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 294 | chip->select_chip(mtd, -1); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 295 | return ret; |
| 296 | } |
| 297 | |
| 298 | /** |
| 299 | * nand_unlock: - Unlock area of NAND pages |
| 300 | * only one consecutive area can be unlocked at one time! |
| 301 | * |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 302 | * @param mtd nand mtd instance |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 303 | * @param start start byte address |
| 304 | * @param length number of bytes to unlock (must be a multiple of |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 305 | * page size nand->writesize) |
Joe Hershberger | cccf595 | 2012-08-22 16:49:42 -0500 | [diff] [blame] | 306 | * @param allexcept if set, unlock everything not selected |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 307 | * |
| 308 | * @return 0 on success, -1 in case of error |
| 309 | */ |
Joe Hershberger | dfa8ba4 | 2012-08-22 16:49:43 -0500 | [diff] [blame] | 310 | int nand_unlock(struct mtd_info *mtd, loff_t start, size_t length, |
| 311 | int allexcept) |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 312 | { |
| 313 | int ret = 0; |
| 314 | int chipnr; |
| 315 | int status; |
| 316 | int page; |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 317 | struct nand_chip *chip = mtd->priv; |
Joe Hershberger | cccf595 | 2012-08-22 16:49:42 -0500 | [diff] [blame] | 318 | |
Tom Rini | 8e40bf6 | 2013-12-16 09:59:34 -0500 | [diff] [blame] | 319 | debug("nand_unlock%s: start: %08llx, length: %zd!\n", |
Joe Hershberger | cccf595 | 2012-08-22 16:49:42 -0500 | [diff] [blame] | 320 | allexcept ? " (allexcept)" : "", start, length); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 321 | |
| 322 | /* select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 323 | chipnr = (int)(start >> chip->chip_shift); |
| 324 | chip->select_chip(mtd, chipnr); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 325 | |
| 326 | /* check the WP bit */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 327 | chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); |
| 328 | if (!(chip->read_byte(mtd) & NAND_STATUS_WP)) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 329 | printf("nand_unlock: Device is write protected!\n"); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 330 | ret = -1; |
| 331 | goto out; |
| 332 | } |
| 333 | |
Joe Hershberger | 8b177d4 | 2013-02-08 09:27:19 +0000 | [diff] [blame] | 334 | /* check the Lock Tight Status */ |
| 335 | page = (int)(start >> chip->page_shift); |
| 336 | chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask); |
| 337 | if (chip->read_byte(mtd) & NAND_LOCK_STATUS_TIGHT) { |
| 338 | printf("nand_unlock: Device is locked tight!\n"); |
| 339 | ret = -1; |
| 340 | goto out; |
| 341 | } |
| 342 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 343 | if ((start & (mtd->erasesize - 1)) != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 344 | printf("nand_unlock: Start address must be beginning of " |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 345 | "nand block!\n"); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 346 | ret = -1; |
| 347 | goto out; |
| 348 | } |
| 349 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 350 | if (length == 0 || (length & (mtd->erasesize - 1)) != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 351 | printf("nand_unlock: Length must be a multiple of nand block " |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 352 | "size %08x!\n", mtd->erasesize); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 353 | ret = -1; |
| 354 | goto out; |
| 355 | } |
| 356 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 357 | /* |
| 358 | * Set length so that the last address is set to the |
| 359 | * starting address of the last block |
| 360 | */ |
| 361 | length -= mtd->erasesize; |
| 362 | |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 363 | /* submit address of first page to unlock */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 364 | chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 365 | |
| 366 | /* submit ADDRESS of LAST page to unlock */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 367 | page += (int)(length >> chip->page_shift); |
Joe Hershberger | cccf595 | 2012-08-22 16:49:42 -0500 | [diff] [blame] | 368 | |
| 369 | /* |
| 370 | * Page addresses for unlocking are supposed to be block-aligned. |
| 371 | * At least some NAND chips use the low bit to indicate that the |
| 372 | * page range should be inverted. |
| 373 | */ |
| 374 | if (allexcept) |
| 375 | page |= 1; |
| 376 | |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 377 | chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, page & chip->pagemask); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 378 | |
| 379 | /* call wait ready function */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 380 | status = chip->waitfunc(mtd, chip); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 381 | /* see if device thinks it succeeded */ |
| 382 | if (status & 0x01) { |
| 383 | /* there was an error */ |
| 384 | ret = -1; |
| 385 | goto out; |
| 386 | } |
| 387 | |
| 388 | out: |
| 389 | /* de-select the NAND device */ |
Nishanth Menon | b20f840 | 2008-12-13 09:43:06 -0600 | [diff] [blame] | 390 | chip->select_chip(mtd, -1); |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 391 | return ret; |
| 392 | } |
William Juul | 52c0796 | 2007-10-31 13:53:06 +0100 | [diff] [blame] | 393 | #endif |
Stefan Roese | d351b2b | 2006-10-10 12:36:02 +0200 | [diff] [blame] | 394 | |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 395 | /** |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 396 | * check_skip_len |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 397 | * |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 398 | * Check if there are any bad blocks, and whether length including bad |
| 399 | * blocks fits into device |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 400 | * |
| 401 | * @param nand NAND device |
| 402 | * @param offset offset in flash |
| 403 | * @param length image length |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 404 | * @param used length of flash needed for the requested length |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 405 | * @return 0 if the image fits and there are no bad blocks |
| 406 | * 1 if the image fits, but there are bad blocks |
| 407 | * -1 if the image does not fit |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 408 | */ |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 409 | static int check_skip_len(nand_info_t *nand, loff_t offset, size_t length, |
| 410 | size_t *used) |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 411 | { |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 412 | size_t len_excl_bad = 0; |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 413 | int ret = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 414 | |
| 415 | while (len_excl_bad < length) { |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 416 | size_t block_len, block_off; |
| 417 | loff_t block_start; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 418 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 419 | if (offset >= nand->size) |
| 420 | return -1; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 421 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 422 | block_start = offset & ~(loff_t)(nand->erasesize - 1); |
| 423 | block_off = offset & (nand->erasesize - 1); |
| 424 | block_len = nand->erasesize - block_off; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 425 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 426 | if (!nand_block_isbad(nand, block_start)) |
| 427 | len_excl_bad += block_len; |
| 428 | else |
| 429 | ret = 1; |
| 430 | |
| 431 | offset += block_len; |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 432 | *used += block_len; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 433 | } |
| 434 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 435 | /* If the length is not a multiple of block_len, adjust. */ |
| 436 | if (len_excl_bad > length) |
| 437 | *used -= (len_excl_bad - length); |
| 438 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 439 | return ret; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 440 | } |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 441 | |
| 442 | #ifdef CONFIG_CMD_NAND_TRIMFFS |
| 443 | static size_t drop_ffs(const nand_info_t *nand, const u_char *buf, |
| 444 | const size_t *len) |
| 445 | { |
htbegin | 610e855 | 2013-03-01 23:00:34 +0000 | [diff] [blame] | 446 | size_t l = *len; |
| 447 | ssize_t i; |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 448 | |
| 449 | for (i = l - 1; i >= 0; i--) |
| 450 | if (buf[i] != 0xFF) |
| 451 | break; |
| 452 | |
| 453 | /* The resulting length must be aligned to the minimum flash I/O size */ |
| 454 | l = i + 1; |
| 455 | l = (l + nand->writesize - 1) / nand->writesize; |
| 456 | l *= nand->writesize; |
| 457 | |
| 458 | /* |
| 459 | * since the input length may be unaligned, prevent access past the end |
| 460 | * of the buffer |
| 461 | */ |
| 462 | return min(l, *len); |
| 463 | } |
| 464 | #endif |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 465 | |
| 466 | /** |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 467 | * nand_verify_page_oob: |
| 468 | * |
| 469 | * Verify a page of NAND flash, including the OOB. |
| 470 | * Reads page of NAND and verifies the contents and OOB against the |
| 471 | * values in ops. |
| 472 | * |
| 473 | * @param nand NAND device |
| 474 | * @param ops MTD operations, including data to verify |
| 475 | * @param ofs offset in flash |
| 476 | * @return 0 in case of success |
| 477 | */ |
| 478 | int nand_verify_page_oob(nand_info_t *nand, struct mtd_oob_ops *ops, loff_t ofs) |
| 479 | { |
| 480 | int rval; |
| 481 | struct mtd_oob_ops vops; |
| 482 | size_t verlen = nand->writesize + nand->oobsize; |
| 483 | |
| 484 | memcpy(&vops, ops, sizeof(vops)); |
| 485 | |
Stephen Warren | 12db818 | 2015-04-14 08:59:00 -0600 | [diff] [blame^] | 486 | vops.datbuf = memalign(ARCH_DMA_MINALIGN, verlen); |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 487 | |
| 488 | if (!vops.datbuf) |
| 489 | return -ENOMEM; |
| 490 | |
| 491 | vops.oobbuf = vops.datbuf + nand->writesize; |
| 492 | |
| 493 | rval = mtd_read_oob(nand, 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 nand NAND device |
| 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 | */ |
| 518 | int nand_verify(nand_info_t *nand, loff_t ofs, size_t len, u_char *buf) |
| 519 | { |
| 520 | int rval = 0; |
| 521 | size_t verofs; |
| 522 | size_t verlen = nand->writesize; |
Stephen Warren | 12db818 | 2015-04-14 08:59:00 -0600 | [diff] [blame^] | 523 | uint8_t *verbuf = memalign(ARCH_DMA_MINALIGN, verlen); |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 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(nand->writesize, (uint32_t)(ofs + len - verofs)); |
| 532 | rval = nand_read(nand, 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 | /** |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 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 |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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. |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 559 | * |
| 560 | * @param nand NAND device |
| 561 | * @param offset offset in flash |
| 562 | * @param length buffer length |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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 |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 567 | * @param buffer buffer to read from |
Ben Gardiner | 1caafbb | 2011-05-24 10:18:35 -0400 | [diff] [blame] | 568 | * @param flags flags modifying the behaviour of the write to NAND |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 569 | * @return 0 in case of success |
| 570 | */ |
Jean-Christophe PLAGNIOL-VILLARD | 2511ba0 | 2009-05-16 14:27:40 +0200 | [diff] [blame] | 571 | int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length, |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 572 | size_t *actual, loff_t lim, u_char *buffer, int flags) |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 573 | { |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 574 | int rval = 0, blocksize; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 575 | size_t left_to_write = *length; |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 576 | size_t used_for_write = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 577 | u_char *p_buffer = buffer; |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 578 | int need_skip; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 579 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 580 | if (actual) |
| 581 | *actual = 0; |
| 582 | |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 583 | blocksize = nand->erasesize; |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 584 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 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 & (nand->writesize - 1)) != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 597 | printf("Attempt to write non page-aligned data\n"); |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 598 | *length = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 599 | return -EINVAL; |
| 600 | } |
| 601 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 602 | need_skip = check_skip_len(nand, offset, *length, &used_for_write); |
| 603 | |
| 604 | if (actual) |
| 605 | *actual = used_for_write; |
| 606 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 607 | if (need_skip < 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 608 | printf("Attempt to write outside the flash area\n"); |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 609 | *length = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 610 | return -EINVAL; |
| 611 | } |
| 612 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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 | |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 619 | if (!need_skip && !(flags & WITH_DROP_FFS)) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 620 | rval = nand_write(nand, offset, length, buffer); |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 621 | |
| 622 | if ((flags & WITH_WR_VERIFY) && !rval) |
| 623 | rval = nand_verify(nand, offset, *length, buffer); |
| 624 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 625 | if (rval == 0) |
| 626 | return 0; |
Scott Wood | 90e0a6b | 2008-11-25 10:47:02 -0600 | [diff] [blame] | 627 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 628 | *length = 0; |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 629 | printf("NAND write to offset %llx failed %d\n", |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 630 | offset, rval); |
Scott Wood | 90e0a6b | 2008-11-25 10:47:02 -0600 | [diff] [blame] | 631 | return rval; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | while (left_to_write > 0) { |
| 635 | size_t block_offset = offset & (nand->erasesize - 1); |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 636 | size_t write_size, truncated_write_size; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 637 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 638 | WATCHDOG_RESET(); |
Giulio Benetti | 749bd66 | 2009-07-31 17:30:34 -0500 | [diff] [blame] | 639 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 640 | if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) { |
| 641 | printf("Skip bad block 0x%08llx\n", |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 642 | offset & ~(nand->erasesize - 1)); |
| 643 | offset += nand->erasesize - block_offset; |
| 644 | continue; |
| 645 | } |
| 646 | |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 647 | if (left_to_write < (blocksize - block_offset)) |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 648 | write_size = left_to_write; |
| 649 | else |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 650 | write_size = blocksize - block_offset; |
| 651 | |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 652 | truncated_write_size = write_size; |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 653 | #ifdef CONFIG_CMD_NAND_TRIMFFS |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 654 | if (flags & WITH_DROP_FFS) |
| 655 | truncated_write_size = drop_ffs(nand, p_buffer, |
| 656 | &write_size); |
Ben Gardiner | 34dd567 | 2011-06-14 16:35:06 -0400 | [diff] [blame] | 657 | #endif |
| 658 | |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 659 | rval = nand_write(nand, offset, &truncated_write_size, |
| 660 | p_buffer); |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 661 | |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 662 | if ((flags & WITH_WR_VERIFY) && !rval) |
| 663 | rval = nand_verify(nand, offset, |
| 664 | truncated_write_size, p_buffer); |
Peter Tyser | c9d92cf | 2015-02-03 11:58:12 -0600 | [diff] [blame] | 665 | |
Peter Tyser | ae6ad78 | 2015-02-03 11:58:16 -0600 | [diff] [blame] | 666 | offset += write_size; |
| 667 | p_buffer += write_size; |
Lei Wen | 4b5deaa | 2011-01-06 11:11:58 +0800 | [diff] [blame] | 668 | |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 669 | if (rval != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 670 | printf("NAND write to offset %llx failed %d\n", |
Wolfgang Denk | 74e0dde | 2008-08-14 14:41:06 +0200 | [diff] [blame] | 671 | offset, rval); |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 672 | *length -= left_to_write; |
| 673 | return rval; |
| 674 | } |
| 675 | |
| 676 | left_to_write -= write_size; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 677 | } |
| 678 | |
| 679 | return 0; |
| 680 | } |
| 681 | |
| 682 | /** |
| 683 | * nand_read_skip_bad: |
| 684 | * |
| 685 | * Read image from NAND flash. |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 686 | * Blocks that are marked bad are skipped and the next block is read |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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. |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 694 | * |
| 695 | * @param nand NAND device |
| 696 | * @param offset offset in flash |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 697 | * @param length buffer length, on return holds number of read bytes |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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 |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 702 | * @param buffer buffer to write to |
| 703 | * @return 0 in case of success |
| 704 | */ |
Jean-Christophe PLAGNIOL-VILLARD | 2511ba0 | 2009-05-16 14:27:40 +0200 | [diff] [blame] | 705 | int nand_read_skip_bad(nand_info_t *nand, loff_t offset, size_t *length, |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 706 | size_t *actual, loff_t lim, u_char *buffer) |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 707 | { |
| 708 | int rval; |
| 709 | size_t left_to_read = *length; |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 710 | size_t used_for_read = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 711 | u_char *p_buffer = buffer; |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 712 | int need_skip; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 713 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 714 | if ((offset & (nand->writesize - 1)) != 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 715 | printf("Attempt to read non page-aligned data\n"); |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 716 | *length = 0; |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 717 | if (actual) |
| 718 | *actual = 0; |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 719 | return -EINVAL; |
| 720 | } |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 721 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 722 | need_skip = check_skip_len(nand, offset, *length, &used_for_read); |
| 723 | |
| 724 | if (actual) |
| 725 | *actual = used_for_read; |
| 726 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 727 | if (need_skip < 0) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 728 | printf("Attempt to read outside the flash area\n"); |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 729 | *length = 0; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 730 | return -EINVAL; |
| 731 | } |
| 732 | |
Tom Rini | 32d9618 | 2013-03-14 05:32:50 +0000 | [diff] [blame] | 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 | |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 739 | if (!need_skip) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 740 | rval = nand_read(nand, offset, length, buffer); |
Valeriy Glushkov | f2aead8 | 2009-07-14 13:51:10 +0300 | [diff] [blame] | 741 | if (!rval || rval == -EUCLEAN) |
| 742 | return 0; |
Scott Wood | fe3b5e1 | 2010-07-30 16:11:41 -0500 | [diff] [blame] | 743 | |
| 744 | *length = 0; |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 745 | printf("NAND read from offset %llx failed %d\n", |
Valeriy Glushkov | f2aead8 | 2009-07-14 13:51:10 +0300 | [diff] [blame] | 746 | offset, rval); |
Scott Wood | 90e0a6b | 2008-11-25 10:47:02 -0600 | [diff] [blame] | 747 | return rval; |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 748 | } |
| 749 | |
| 750 | while (left_to_read > 0) { |
| 751 | size_t block_offset = offset & (nand->erasesize - 1); |
| 752 | size_t read_length; |
| 753 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 754 | WATCHDOG_RESET(); |
Giulio Benetti | 749bd66 | 2009-07-31 17:30:34 -0500 | [diff] [blame] | 755 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 756 | if (nand_block_isbad(nand, offset & ~(nand->erasesize - 1))) { |
| 757 | printf("Skipping bad block 0x%08llx\n", |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 758 | offset & ~(nand->erasesize - 1)); |
| 759 | offset += nand->erasesize - block_offset; |
| 760 | continue; |
| 761 | } |
| 762 | |
| 763 | if (left_to_read < (nand->erasesize - block_offset)) |
| 764 | read_length = left_to_read; |
| 765 | else |
| 766 | read_length = nand->erasesize - block_offset; |
| 767 | |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 768 | rval = nand_read(nand, offset, &read_length, p_buffer); |
Valeriy Glushkov | f2aead8 | 2009-07-14 13:51:10 +0300 | [diff] [blame] | 769 | if (rval && rval != -EUCLEAN) { |
Benoît Thébaudeau | e26708e | 2012-11-05 10:15:46 +0000 | [diff] [blame] | 770 | printf("NAND read from offset %llx failed %d\n", |
Wolfgang Denk | 74e0dde | 2008-08-14 14:41:06 +0200 | [diff] [blame] | 771 | offset, rval); |
Scott Wood | cc5f339 | 2008-06-12 13:20:16 -0500 | [diff] [blame] | 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 | } |
Benoît Thébaudeau | 5661f70 | 2012-11-16 20:20:54 +0100 | [diff] [blame] | 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 | */ |
| 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 nand NAND device |
| 815 | * @param offset offset in flash |
| 816 | * @return 0 if the block is still good |
| 817 | */ |
| 818 | int nand_torture(nand_info_t *nand, loff_t offset) |
| 819 | { |
| 820 | u_char patterns[] = {0xa5, 0x5a, 0x00}; |
| 821 | struct erase_info instr = { |
| 822 | .mtd = nand, |
| 823 | .addr = offset, |
| 824 | .len = nand->erasesize, |
| 825 | }; |
| 826 | size_t retlen; |
| 827 | int err, ret = -1, i, patt_count; |
| 828 | u_char *buf; |
| 829 | |
| 830 | if ((offset & (nand->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 + nand->erasesize > nand->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(nand->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 = nand->erase(nand, &instr); |
| 850 | if (err) { |
| 851 | printf("%s: erase() failed for block at 0x%llx: %d\n", |
| 852 | nand->name, instr.addr, err); |
| 853 | goto out; |
| 854 | } |
| 855 | |
| 856 | /* Make sure the block contains only 0xff bytes */ |
| 857 | err = nand->read(nand, offset, nand->erasesize, &retlen, buf); |
| 858 | if ((err && err != -EUCLEAN) || retlen != nand->erasesize) { |
| 859 | printf("%s: read() failed for block at 0x%llx: %d\n", |
| 860 | nand->name, instr.addr, err); |
| 861 | goto out; |
| 862 | } |
| 863 | |
| 864 | err = check_pattern(buf, 0xff, nand->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], nand->erasesize); |
| 874 | err = nand->write(nand, offset, nand->erasesize, &retlen, buf); |
| 875 | if (err || retlen != nand->erasesize) { |
| 876 | printf("%s: write() failed for block at 0x%llx: %d\n", |
| 877 | nand->name, instr.addr, err); |
| 878 | goto out; |
| 879 | } |
| 880 | |
| 881 | err = nand->read(nand, offset, nand->erasesize, &retlen, buf); |
| 882 | if ((err && err != -EUCLEAN) || retlen != nand->erasesize) { |
| 883 | printf("%s: read() failed for block at 0x%llx: %d\n", |
| 884 | nand->name, instr.addr, err); |
| 885 | goto out; |
| 886 | } |
| 887 | |
| 888 | err = check_pattern(buf, patterns[i], nand->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 |