blob: 8b4f7388152c70e209d2f8f8193d3ea0a35306e3 [file] [log] [blame]
Stefan Roese2255b2d2006-10-10 12:36:02 +02001/*
Marcel Ziswiler7817cb22007-12-30 03:30:46 +01002 * drivers/mtd/nand/nand_util.c
Stefan Roese2255b2d2006-10-10 12:36:02 +02003 *
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 *
14 * See file CREDITS for list of people who contributed to this
15 * project.
16 *
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License version
19 * 2 as published by the Free Software Foundation.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 * MA 02111-1307 USA
30 *
Scott Woodf9a52542010-07-30 16:11:41 -050031 * Copyright 2010 Freescale Semiconductor
32 * The portions of this file whose copyright is held by Freescale and which
33 * are not considered a derived work of GPL v2-only code may be distributed
34 * and/or modified under the terms of the GNU General Public License as
35 * published by the Free Software Foundation; either version 2 of the
36 * License, or (at your option) any later version.
Stefan Roese2255b2d2006-10-10 12:36:02 +020037 */
38
39#include <common.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020040#include <command.h>
41#include <watchdog.h>
42#include <malloc.h>
Dirk Behme3a6d56c2007-08-02 17:42:08 +020043#include <div64.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020044
William Juulcfa460a2007-10-31 13:53:06 +010045#include <asm/errno.h>
46#include <linux/mtd/mtd.h>
Stefan Roese2255b2d2006-10-10 12:36:02 +020047#include <nand.h>
48#include <jffs2/jffs2.h>
49
50typedef struct erase_info erase_info_t;
51typedef struct mtd_info mtd_info_t;
52
53/* support only for native endian JFFS2 */
54#define cpu_to_je16(x) (x)
55#define cpu_to_je32(x) (x)
56
57/*****************************************************************************/
58static int nand_block_bad_scrub(struct mtd_info *mtd, loff_t ofs, int getchip)
59{
60 return 0;
61}
62
63/**
64 * nand_erase_opts: - erase NAND flash with support for various options
65 * (jffs2 formating)
66 *
67 * @param meminfo NAND device to erase
68 * @param opts options, @see struct nand_erase_options
69 * @return 0 in case of success
70 *
71 * This code is ported from flash_eraseall.c from Linux mtd utils by
72 * Arcom Control System Ltd.
73 */
74int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts)
75{
76 struct jffs2_unknown_node cleanmarker;
Stefan Roese2255b2d2006-10-10 12:36:02 +020077 erase_info_t erase;
Scott Wood30486322010-08-25 14:43:29 -050078 unsigned long erase_length, erased_length; /* in blocks */
Stefan Roese2255b2d2006-10-10 12:36:02 +020079 int bbtest = 1;
80 int result;
81 int percent_complete = -1;
82 int (*nand_block_bad_old)(struct mtd_info *, loff_t, int) = NULL;
83 const char *mtd_device = meminfo->name;
William Juulcfa460a2007-10-31 13:53:06 +010084 struct mtd_oob_ops oob_opts;
85 struct nand_chip *chip = meminfo->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +020086
Scott Wood30486322010-08-25 14:43:29 -050087 if ((opts->offset & (meminfo->writesize - 1)) != 0) {
88 printf("Attempt to erase non page aligned data\n");
89 return -1;
90 }
91
Stefan Roese2255b2d2006-10-10 12:36:02 +020092 memset(&erase, 0, sizeof(erase));
William Juulcfa460a2007-10-31 13:53:06 +010093 memset(&oob_opts, 0, sizeof(oob_opts));
Stefan Roese2255b2d2006-10-10 12:36:02 +020094
95 erase.mtd = meminfo;
96 erase.len = meminfo->erasesize;
Stefan Roese856f0542006-10-28 15:55:52 +020097 erase.addr = opts->offset;
Scott Wood30486322010-08-25 14:43:29 -050098 erase_length = lldiv(opts->length + meminfo->erasesize - 1,
99 meminfo->erasesize);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200100
William Juulcfa460a2007-10-31 13:53:06 +0100101 cleanmarker.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
102 cleanmarker.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
103 cleanmarker.totlen = cpu_to_je32(8);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200104
105 /* scrub option allows to erase badblock. To prevent internal
106 * check from erase() method, set block check method to dummy
107 * and disable bad block table while erasing.
108 */
109 if (opts->scrub) {
110 struct nand_chip *priv_nand = meminfo->priv;
111
112 nand_block_bad_old = priv_nand->block_bad;
113 priv_nand->block_bad = nand_block_bad_scrub;
114 /* we don't need the bad block table anymore...
115 * after scrub, there are no bad blocks left!
116 */
117 if (priv_nand->bbt) {
118 kfree(priv_nand->bbt);
119 }
120 priv_nand->bbt = NULL;
121 }
122
Scott Wood30486322010-08-25 14:43:29 -0500123 for (erased_length = 0;
124 erased_length < erase_length;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200125 erase.addr += meminfo->erasesize) {
William Juul4cbb6512007-11-08 10:39:53 +0100126
Stefan Roese2255b2d2006-10-10 12:36:02 +0200127 WATCHDOG_RESET ();
128
129 if (!opts->scrub && bbtest) {
130 int ret = meminfo->block_isbad(meminfo, erase.addr);
131 if (ret > 0) {
132 if (!opts->quiet)
133 printf("\rSkipping bad block at "
Stefan Roese8d2effe2009-05-11 16:03:55 +0200134 "0x%08llx "
Wolfgang Denk87621bc2006-10-12 11:43:47 +0200135 " \n",
136 erase.addr);
Scott Wood30486322010-08-25 14:43:29 -0500137
138 if (!opts->spread)
139 erased_length++;
140
Stefan Roese2255b2d2006-10-10 12:36:02 +0200141 continue;
142
143 } else if (ret < 0) {
144 printf("\n%s: MTD get bad block failed: %d\n",
145 mtd_device,
146 ret);
147 return -1;
148 }
149 }
150
Scott Wood30486322010-08-25 14:43:29 -0500151 erased_length++;
152
Stefan Roese2255b2d2006-10-10 12:36:02 +0200153 result = meminfo->erase(meminfo, &erase);
154 if (result != 0) {
155 printf("\n%s: MTD Erase failure: %d\n",
156 mtd_device, result);
157 continue;
158 }
159
160 /* format for JFFS2 ? */
Scott Woodbd78bc62008-10-29 14:20:26 -0500161 if (opts->jffs2 && chip->ecc.layout->oobavail >= 8) {
162 chip->ops.ooblen = 8;
William Juulcfa460a2007-10-31 13:53:06 +0100163 chip->ops.datbuf = NULL;
Scott Woodbd78bc62008-10-29 14:20:26 -0500164 chip->ops.oobbuf = (uint8_t *)&cleanmarker;
165 chip->ops.ooboffs = 0;
166 chip->ops.mode = MTD_OOB_AUTO;
William Juul4cbb6512007-11-08 10:39:53 +0100167
William Juulcfa460a2007-10-31 13:53:06 +0100168 result = meminfo->write_oob(meminfo,
Scott Woodbd78bc62008-10-29 14:20:26 -0500169 erase.addr,
170 &chip->ops);
William Juulcfa460a2007-10-31 13:53:06 +0100171 if (result != 0) {
172 printf("\n%s: MTD writeoob failure: %d\n",
Scott Woodbd78bc62008-10-29 14:20:26 -0500173 mtd_device, result);
William Juulcfa460a2007-10-31 13:53:06 +0100174 continue;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200175 }
176 }
177
178 if (!opts->quiet) {
Scott Wood30486322010-08-25 14:43:29 -0500179 unsigned long long n = erased_length * 100ULL;
Matthias Fuchs5bd7fe92007-09-11 17:04:00 +0200180 int percent;
181
182 do_div(n, erase_length);
183 percent = (int)n;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200184
185 /* output progress message only at whole percent
186 * steps to reduce the number of messages printed
187 * on (slow) serial consoles
188 */
189 if (percent != percent_complete) {
190 percent_complete = percent;
191
Stefan Roese8d2effe2009-05-11 16:03:55 +0200192 printf("\rErasing at 0x%llx -- %3d%% complete.",
Scott Woodbd78bc62008-10-29 14:20:26 -0500193 erase.addr, percent);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200194
195 if (opts->jffs2 && result == 0)
Stefan Roese8d2effe2009-05-11 16:03:55 +0200196 printf(" Cleanmarker written at 0x%llx.",
Scott Woodbd78bc62008-10-29 14:20:26 -0500197 erase.addr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200198 }
199 }
200 }
201 if (!opts->quiet)
202 printf("\n");
203
204 if (nand_block_bad_old) {
205 struct nand_chip *priv_nand = meminfo->priv;
206
207 priv_nand->block_bad = nand_block_bad_old;
208 priv_nand->scan_bbt(meminfo);
209 }
210
211 return 0;
212}
213
Nishanth Menon50657c22008-12-13 09:43:06 -0600214#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
215
Stefan Roese2255b2d2006-10-10 12:36:02 +0200216/******************************************************************************
217 * Support for locking / unlocking operations of some NAND devices
218 *****************************************************************************/
219
220#define NAND_CMD_LOCK 0x2a
221#define NAND_CMD_LOCK_TIGHT 0x2c
222#define NAND_CMD_UNLOCK1 0x23
223#define NAND_CMD_UNLOCK2 0x24
224#define NAND_CMD_LOCK_STATUS 0x7a
225
226/**
227 * nand_lock: Set all pages of NAND flash chip to the LOCK or LOCK-TIGHT
228 * state
229 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600230 * @param mtd nand mtd instance
Stefan Roese2255b2d2006-10-10 12:36:02 +0200231 * @param tight bring device in lock tight mode
232 *
233 * @return 0 on success, -1 in case of error
234 *
235 * The lock / lock-tight command only applies to the whole chip. To get some
236 * parts of the chip lock and others unlocked use the following sequence:
237 *
238 * - Lock all pages of the chip using nand_lock(mtd, 0) (or the lockpre pin)
239 * - Call nand_unlock() once for each consecutive area to be unlocked
240 * - If desired: Bring the chip to the lock-tight state using nand_lock(mtd, 1)
241 *
242 * If the device is in lock-tight state software can't change the
243 * current active lock/unlock state of all pages. nand_lock() / nand_unlock()
244 * calls will fail. It is only posible to leave lock-tight state by
245 * an hardware signal (low pulse on _WP pin) or by power down.
246 */
Nishanth Menon50657c22008-12-13 09:43:06 -0600247int nand_lock(struct mtd_info *mtd, int tight)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200248{
249 int ret = 0;
250 int status;
Nishanth Menon50657c22008-12-13 09:43:06 -0600251 struct nand_chip *chip = mtd->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200252
253 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600254 chip->select_chip(mtd, 0);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200255
Nishanth Menon50657c22008-12-13 09:43:06 -0600256 chip->cmdfunc(mtd,
Stefan Roese2255b2d2006-10-10 12:36:02 +0200257 (tight ? NAND_CMD_LOCK_TIGHT : NAND_CMD_LOCK),
258 -1, -1);
259
260 /* call wait ready function */
Nishanth Menon50657c22008-12-13 09:43:06 -0600261 status = chip->waitfunc(mtd, chip);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200262
263 /* see if device thinks it succeeded */
264 if (status & 0x01) {
265 ret = -1;
266 }
267
268 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600269 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200270 return ret;
271}
272
273/**
274 * nand_get_lock_status: - query current lock state from one page of NAND
275 * flash
276 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600277 * @param mtd nand mtd instance
Stefan Roese2255b2d2006-10-10 12:36:02 +0200278 * @param offset page address to query (muss be page aligned!)
279 *
280 * @return -1 in case of error
281 * >0 lock status:
282 * bitfield with the following combinations:
283 * NAND_LOCK_STATUS_TIGHT: page in tight state
284 * NAND_LOCK_STATUS_LOCK: page locked
285 * NAND_LOCK_STATUS_UNLOCK: page unlocked
286 *
287 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200288int nand_get_lock_status(struct mtd_info *mtd, loff_t offset)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200289{
290 int ret = 0;
291 int chipnr;
292 int page;
Nishanth Menon50657c22008-12-13 09:43:06 -0600293 struct nand_chip *chip = mtd->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200294
295 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600296 chipnr = (int)(offset >> chip->chip_shift);
297 chip->select_chip(mtd, chipnr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200298
299
Nishanth Menon50657c22008-12-13 09:43:06 -0600300 if ((offset & (mtd->writesize - 1)) != 0) {
Stefan Roese2255b2d2006-10-10 12:36:02 +0200301 printf ("nand_get_lock_status: "
302 "Start address must be beginning of "
303 "nand page!\n");
304 ret = -1;
305 goto out;
306 }
307
308 /* check the Lock Status */
Nishanth Menon50657c22008-12-13 09:43:06 -0600309 page = (int)(offset >> chip->page_shift);
310 chip->cmdfunc(mtd, NAND_CMD_LOCK_STATUS, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200311
Nishanth Menon50657c22008-12-13 09:43:06 -0600312 ret = chip->read_byte(mtd) & (NAND_LOCK_STATUS_TIGHT
Stefan Roese2255b2d2006-10-10 12:36:02 +0200313 | NAND_LOCK_STATUS_LOCK
314 | NAND_LOCK_STATUS_UNLOCK);
315
316 out:
317 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600318 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200319 return ret;
320}
321
322/**
323 * nand_unlock: - Unlock area of NAND pages
324 * only one consecutive area can be unlocked at one time!
325 *
Nishanth Menon50657c22008-12-13 09:43:06 -0600326 * @param mtd nand mtd instance
Stefan Roese2255b2d2006-10-10 12:36:02 +0200327 * @param start start byte address
328 * @param length number of bytes to unlock (must be a multiple of
William Juulcfa460a2007-10-31 13:53:06 +0100329 * page size nand->writesize)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200330 *
331 * @return 0 on success, -1 in case of error
332 */
Nishanth Menon50657c22008-12-13 09:43:06 -0600333int nand_unlock(struct mtd_info *mtd, ulong start, ulong length)
Stefan Roese2255b2d2006-10-10 12:36:02 +0200334{
335 int ret = 0;
336 int chipnr;
337 int status;
338 int page;
Nishanth Menon50657c22008-12-13 09:43:06 -0600339 struct nand_chip *chip = mtd->priv;
Stefan Roese2255b2d2006-10-10 12:36:02 +0200340 printf ("nand_unlock: start: %08x, length: %d!\n",
341 (int)start, (int)length);
342
343 /* select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600344 chipnr = (int)(start >> chip->chip_shift);
345 chip->select_chip(mtd, chipnr);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200346
347 /* check the WP bit */
Nishanth Menon50657c22008-12-13 09:43:06 -0600348 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
349 if (!(chip->read_byte(mtd) & NAND_STATUS_WP)) {
Stefan Roese2255b2d2006-10-10 12:36:02 +0200350 printf ("nand_unlock: Device is write protected!\n");
351 ret = -1;
352 goto out;
353 }
354
Nishanth Menon50657c22008-12-13 09:43:06 -0600355 if ((start & (mtd->erasesize - 1)) != 0) {
Stefan Roese2255b2d2006-10-10 12:36:02 +0200356 printf ("nand_unlock: Start address must be beginning of "
Nishanth Menon50657c22008-12-13 09:43:06 -0600357 "nand block!\n");
Stefan Roese2255b2d2006-10-10 12:36:02 +0200358 ret = -1;
359 goto out;
360 }
361
Nishanth Menon50657c22008-12-13 09:43:06 -0600362 if (length == 0 || (length & (mtd->erasesize - 1)) != 0) {
363 printf ("nand_unlock: Length must be a multiple of nand block "
364 "size %08x!\n", mtd->erasesize);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200365 ret = -1;
366 goto out;
367 }
368
Nishanth Menon50657c22008-12-13 09:43:06 -0600369 /*
370 * Set length so that the last address is set to the
371 * starting address of the last block
372 */
373 length -= mtd->erasesize;
374
Stefan Roese2255b2d2006-10-10 12:36:02 +0200375 /* submit address of first page to unlock */
Nishanth Menon50657c22008-12-13 09:43:06 -0600376 page = (int)(start >> chip->page_shift);
377 chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200378
379 /* submit ADDRESS of LAST page to unlock */
Nishanth Menon50657c22008-12-13 09:43:06 -0600380 page += (int)(length >> chip->page_shift);
381 chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, page & chip->pagemask);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200382
383 /* call wait ready function */
Nishanth Menon50657c22008-12-13 09:43:06 -0600384 status = chip->waitfunc(mtd, chip);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200385 /* see if device thinks it succeeded */
386 if (status & 0x01) {
387 /* there was an error */
388 ret = -1;
389 goto out;
390 }
391
392 out:
393 /* de-select the NAND device */
Nishanth Menon50657c22008-12-13 09:43:06 -0600394 chip->select_chip(mtd, -1);
Stefan Roese2255b2d2006-10-10 12:36:02 +0200395 return ret;
396}
William Juulcfa460a2007-10-31 13:53:06 +0100397#endif
Stefan Roese2255b2d2006-10-10 12:36:02 +0200398
Scott Wooddfbf6172008-06-12 13:20:16 -0500399/**
Scott Woodf9a52542010-07-30 16:11:41 -0500400 * check_skip_len
Scott Wooddfbf6172008-06-12 13:20:16 -0500401 *
Scott Woodf9a52542010-07-30 16:11:41 -0500402 * Check if there are any bad blocks, and whether length including bad
403 * blocks fits into device
Scott Wooddfbf6172008-06-12 13:20:16 -0500404 *
405 * @param nand NAND device
406 * @param offset offset in flash
407 * @param length image length
Scott Woodf9a52542010-07-30 16:11:41 -0500408 * @return 0 if the image fits and there are no bad blocks
409 * 1 if the image fits, but there are bad blocks
410 * -1 if the image does not fit
Scott Wooddfbf6172008-06-12 13:20:16 -0500411 */
Scott Woodf9a52542010-07-30 16:11:41 -0500412static int check_skip_len(nand_info_t *nand, loff_t offset, size_t length)
Scott Wooddfbf6172008-06-12 13:20:16 -0500413{
Scott Wooddfbf6172008-06-12 13:20:16 -0500414 size_t len_excl_bad = 0;
Scott Woodf9a52542010-07-30 16:11:41 -0500415 int ret = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500416
417 while (len_excl_bad < length) {
Scott Woodf9a52542010-07-30 16:11:41 -0500418 size_t block_len, block_off;
419 loff_t block_start;
Scott Wooddfbf6172008-06-12 13:20:16 -0500420
Daniel Hobi0ec81db2009-12-01 14:05:55 +0100421 if (offset >= nand->size)
Scott Woodf9a52542010-07-30 16:11:41 -0500422 return -1;
423
424 block_start = offset & ~(loff_t)(nand->erasesize - 1);
425 block_off = offset & (nand->erasesize - 1);
426 block_len = nand->erasesize - block_off;
427
428 if (!nand_block_isbad(nand, block_start))
429 len_excl_bad += block_len;
430 else
431 ret = 1;
432
433 offset += block_len;
Scott Wooddfbf6172008-06-12 13:20:16 -0500434 }
435
Scott Woodf9a52542010-07-30 16:11:41 -0500436 return ret;
Scott Wooddfbf6172008-06-12 13:20:16 -0500437}
438
439/**
440 * nand_write_skip_bad:
441 *
442 * Write image to NAND flash.
443 * Blocks that are marked bad are skipped and the is written to the next
444 * block instead as long as the image is short enough to fit even after
445 * skipping the bad blocks.
446 *
447 * @param nand NAND device
448 * @param offset offset in flash
449 * @param length buffer length
Lei Wen47fc18f2011-01-06 11:11:58 +0800450 * @param buffer buffer to read from
451 * @param withoob whether write with yaffs format
Scott Wooddfbf6172008-06-12 13:20:16 -0500452 * @return 0 in case of success
453 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200454int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
Lei Wen47fc18f2011-01-06 11:11:58 +0800455 u_char *buffer, int withoob)
Scott Wooddfbf6172008-06-12 13:20:16 -0500456{
Lei Wen47fc18f2011-01-06 11:11:58 +0800457 int rval = 0, blocksize;
Scott Wooddfbf6172008-06-12 13:20:16 -0500458 size_t left_to_write = *length;
Scott Wooddfbf6172008-06-12 13:20:16 -0500459 u_char *p_buffer = buffer;
Scott Woodf9a52542010-07-30 16:11:41 -0500460 int need_skip;
Scott Wooddfbf6172008-06-12 13:20:16 -0500461
Lei Wen47fc18f2011-01-06 11:11:58 +0800462#ifdef CONFIG_CMD_NAND_YAFFS
463 if (withoob) {
464 int pages;
465 pages = nand->erasesize / nand->writesize;
466 blocksize = (pages * nand->oobsize) + nand->erasesize;
467 if (*length % (nand->writesize + nand->oobsize)) {
468 printf ("Attempt to write incomplete page"
469 " in yaffs mode\n");
470 return -EINVAL;
471 }
472 } else
473#endif
474 {
475 blocksize = nand->erasesize;
476 }
477
Scott Woodf9a52542010-07-30 16:11:41 -0500478 /*
479 * nand_write() handles unaligned, partial page writes.
480 *
481 * We allow length to be unaligned, for convenience in
482 * using the $filesize variable.
483 *
484 * However, starting at an unaligned offset makes the
485 * semantics of bad block skipping ambiguous (really,
486 * you should only start a block skipping access at a
487 * partition boundary). So don't try to handle that.
488 */
489 if ((offset & (nand->writesize - 1)) != 0) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500490 printf ("Attempt to write non page aligned data\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500491 *length = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500492 return -EINVAL;
493 }
494
Scott Woodf9a52542010-07-30 16:11:41 -0500495 need_skip = check_skip_len(nand, offset, *length);
496 if (need_skip < 0) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500497 printf ("Attempt to write outside the flash area\n");
Scott Woodf9a52542010-07-30 16:11:41 -0500498 *length = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500499 return -EINVAL;
500 }
501
Scott Woodf9a52542010-07-30 16:11:41 -0500502 if (!need_skip) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500503 rval = nand_write (nand, offset, length, buffer);
Scott Woodf9a52542010-07-30 16:11:41 -0500504 if (rval == 0)
505 return 0;
Scott Wood2077e342008-11-25 10:47:02 -0600506
Scott Woodf9a52542010-07-30 16:11:41 -0500507 *length = 0;
508 printf ("NAND write to offset %llx failed %d\n",
509 offset, rval);
Scott Wood2077e342008-11-25 10:47:02 -0600510 return rval;
Scott Wooddfbf6172008-06-12 13:20:16 -0500511 }
512
513 while (left_to_write > 0) {
514 size_t block_offset = offset & (nand->erasesize - 1);
515 size_t write_size;
516
Giulio Benetti1fc1d9a2009-07-31 17:30:34 -0500517 WATCHDOG_RESET ();
518
Scott Wooddfbf6172008-06-12 13:20:16 -0500519 if (nand_block_isbad (nand, offset & ~(nand->erasesize - 1))) {
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200520 printf ("Skip bad block 0x%08llx\n",
Scott Wooddfbf6172008-06-12 13:20:16 -0500521 offset & ~(nand->erasesize - 1));
522 offset += nand->erasesize - block_offset;
523 continue;
524 }
525
Lei Wen47fc18f2011-01-06 11:11:58 +0800526 if (left_to_write < (blocksize - block_offset))
Scott Wooddfbf6172008-06-12 13:20:16 -0500527 write_size = left_to_write;
528 else
Lei Wen47fc18f2011-01-06 11:11:58 +0800529 write_size = blocksize - block_offset;
Scott Wooddfbf6172008-06-12 13:20:16 -0500530
Lei Wen47fc18f2011-01-06 11:11:58 +0800531#ifdef CONFIG_CMD_NAND_YAFFS
532 if (withoob) {
533 int page, pages;
534 size_t pagesize = nand->writesize;
535 size_t pagesize_oob = pagesize + nand->oobsize;
536 struct mtd_oob_ops ops;
537
538 ops.len = pagesize;
539 ops.ooblen = nand->oobsize;
540 ops.mode = MTD_OOB_AUTO;
541 ops.ooboffs = 0;
542
543 pages = write_size / pagesize_oob;
544 for (page = 0; page < pages; page++) {
545 ops.datbuf = p_buffer;
546 ops.oobbuf = ops.datbuf + pagesize;
547
548 rval = nand->write_oob(nand, offset, &ops);
549 if (!rval)
550 break;
551
552 offset += pagesize;
553 p_buffer += pagesize_oob;
554 }
555 }
556 else
557#endif
558 {
559 rval = nand_write (nand, offset, &write_size, p_buffer);
560 offset += write_size;
561 p_buffer += write_size;
562 }
563
Scott Wooddfbf6172008-06-12 13:20:16 -0500564 if (rval != 0) {
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200565 printf ("NAND write to offset %llx failed %d\n",
Wolfgang Denk4b070802008-08-14 14:41:06 +0200566 offset, rval);
Scott Wooddfbf6172008-06-12 13:20:16 -0500567 *length -= left_to_write;
568 return rval;
569 }
570
571 left_to_write -= write_size;
Scott Wooddfbf6172008-06-12 13:20:16 -0500572 }
573
574 return 0;
575}
576
577/**
578 * nand_read_skip_bad:
579 *
580 * Read image from NAND flash.
581 * Blocks that are marked bad are skipped and the next block is readen
582 * instead as long as the image is short enough to fit even after skipping the
583 * bad blocks.
584 *
585 * @param nand NAND device
586 * @param offset offset in flash
587 * @param length buffer length, on return holds remaining bytes to read
588 * @param buffer buffer to write to
589 * @return 0 in case of success
590 */
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200591int nand_read_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
Scott Wooddfbf6172008-06-12 13:20:16 -0500592 u_char *buffer)
593{
594 int rval;
595 size_t left_to_read = *length;
Scott Wooddfbf6172008-06-12 13:20:16 -0500596 u_char *p_buffer = buffer;
Scott Woodf9a52542010-07-30 16:11:41 -0500597 int need_skip;
Scott Wooddfbf6172008-06-12 13:20:16 -0500598
Scott Woodf9a52542010-07-30 16:11:41 -0500599 if ((offset & (nand->writesize - 1)) != 0) {
600 printf ("Attempt to read non page aligned data\n");
601 *length = 0;
Scott Wooddfbf6172008-06-12 13:20:16 -0500602 return -EINVAL;
603 }
604
Scott Woodf9a52542010-07-30 16:11:41 -0500605 need_skip = check_skip_len(nand, offset, *length);
606 if (need_skip < 0) {
607 printf ("Attempt to read outside the flash area\n");
608 *length = 0;
609 return -EINVAL;
610 }
611
612 if (!need_skip) {
Scott Wooddfbf6172008-06-12 13:20:16 -0500613 rval = nand_read (nand, offset, length, buffer);
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300614 if (!rval || rval == -EUCLEAN)
615 return 0;
Scott Woodf9a52542010-07-30 16:11:41 -0500616
617 *length = 0;
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300618 printf ("NAND read from offset %llx failed %d\n",
619 offset, rval);
Scott Wood2077e342008-11-25 10:47:02 -0600620 return rval;
Scott Wooddfbf6172008-06-12 13:20:16 -0500621 }
622
623 while (left_to_read > 0) {
624 size_t block_offset = offset & (nand->erasesize - 1);
625 size_t read_length;
626
Giulio Benetti1fc1d9a2009-07-31 17:30:34 -0500627 WATCHDOG_RESET ();
628
Scott Wooddfbf6172008-06-12 13:20:16 -0500629 if (nand_block_isbad (nand, offset & ~(nand->erasesize - 1))) {
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200630 printf ("Skipping bad block 0x%08llx\n",
Scott Wooddfbf6172008-06-12 13:20:16 -0500631 offset & ~(nand->erasesize - 1));
632 offset += nand->erasesize - block_offset;
633 continue;
634 }
635
636 if (left_to_read < (nand->erasesize - block_offset))
637 read_length = left_to_read;
638 else
639 read_length = nand->erasesize - block_offset;
640
641 rval = nand_read (nand, offset, &read_length, p_buffer);
Valeriy Glushkov3ebf70d2009-07-14 13:51:10 +0300642 if (rval && rval != -EUCLEAN) {
Jean-Christophe PLAGNIOL-VILLARD378adfc2009-05-16 14:27:40 +0200643 printf ("NAND read from offset %llx failed %d\n",
Wolfgang Denk4b070802008-08-14 14:41:06 +0200644 offset, rval);
Scott Wooddfbf6172008-06-12 13:20:16 -0500645 *length -= left_to_read;
646 return rval;
647 }
648
649 left_to_read -= read_length;
650 offset += read_length;
651 p_buffer += read_length;
652 }
653
654 return 0;
655}