blob: 8495829900c4a179642d80ddadbbe04ad748fad7 [file] [log] [blame]
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001/*
2 * drivers/mtd/nand.c
3 *
4 * Overview:
5 * This is the generic MTD driver for NAND flash devices. It should be
6 * capable of working with almost all NAND chips currently available.
7 * Basic support for AG-AND chips is provided.
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02008 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02009 * Additional technical information is available on
10 * http://www.linux-mtd.infradead.org/tech/nand.html
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020011 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020012 * Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
13 * 2002 Thomas Gleixner (tglx@linutronix.de)
14 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020015 * 02-08-2004 tglx: support for strange chips, which cannot auto increment
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020016 * pages on read / read_oob
17 *
18 * 03-17-2004 tglx: Check ready before auto increment check. Simon Bayes
19 * pointed this out, as he marked an auto increment capable chip
20 * as NOAUTOINCR in the board driver.
21 * Make reads over block boundaries work too
22 *
23 * 04-14-2004 tglx: first working version for 2k page size chips
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020024 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020025 * 05-19-2004 tglx: Basic support for Renesas AG-AND chips
26 *
27 * 09-24-2004 tglx: add support for hardware controllers (e.g. ECC) shared
28 * among multiple independend devices. Suggestions and initial patch
29 * from Ben Dooks <ben-mtd@fluff.org>
30 *
31 * Credits:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020032 * David Woodhouse for adding multichip support
33 *
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020034 * Aleph One Ltd. and Toby Churchill Ltd. for supporting the
35 * rework for 2K page size chips
36 *
37 * TODO:
38 * Enable cached programming for 2k page size chips
39 * Check, if mtd->ecctype should be set to MTD_ECC_HW
40 * if we have HW ecc support.
41 * The AG-AND chips have nice features for speed improvement,
42 * which are not supported yet. Read / program 4 pages in one go.
43 *
44 * $Id: nand_base.c,v 1.126 2004/12/13 11:22:25 lavinen Exp $
45 *
46 * This program is free software; you can redistribute it and/or modify
47 * it under the terms of the GNU General Public License version 2 as
48 * published by the Free Software Foundation.
49 *
50 */
51
52/* XXX U-BOOT XXX */
53#if 0
54#include <linux/delay.h>
55#include <linux/errno.h>
56#include <linux/sched.h>
57#include <linux/slab.h>
58#include <linux/types.h>
59#include <linux/mtd/mtd.h>
60#include <linux/mtd/nand.h>
61#include <linux/mtd/nand_ecc.h>
62#include <linux/mtd/compatmac.h>
63#include <linux/interrupt.h>
64#include <linux/bitops.h>
65#include <asm/io.h>
66
67#ifdef CONFIG_MTD_PARTITIONS
68#include <linux/mtd/partitions.h>
69#endif
70
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +020071#endif
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020072
73#include <common.h>
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +010074
Marian Balakowicz6a076752006-04-08 19:08:06 +020075#if (CONFIG_COMMANDS & CFG_CMD_NAND) && !defined(CFG_NAND_LEGACY)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020076
77#include <malloc.h>
78#include <watchdog.h>
79#include <linux/mtd/compat.h>
80#include <linux/mtd/mtd.h>
81#include <linux/mtd/nand.h>
82#include <linux/mtd/nand_ecc.h>
83
84#include <asm/io.h>
85#include <asm/errno.h>
86
87#ifdef CONFIG_JFFS2_NAND
88#include <jffs2/jffs2.h>
89#endif
90
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +020091/* Define default oob placement schemes for large and small page devices */
92static struct nand_oobinfo nand_oob_8 = {
93 .useecc = MTD_NANDECC_AUTOPLACE,
94 .eccbytes = 3,
95 .eccpos = {0, 1, 2},
96 .oobfree = { {3, 2}, {6, 2} }
97};
98
99static struct nand_oobinfo nand_oob_16 = {
100 .useecc = MTD_NANDECC_AUTOPLACE,
101 .eccbytes = 6,
102 .eccpos = {0, 1, 2, 3, 6, 7},
103 .oobfree = { {8, 8} }
104};
105
106static struct nand_oobinfo nand_oob_64 = {
107 .useecc = MTD_NANDECC_AUTOPLACE,
108 .eccbytes = 24,
109 .eccpos = {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200110 40, 41, 42, 43, 44, 45, 46, 47,
111 48, 49, 50, 51, 52, 53, 54, 55,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200112 56, 57, 58, 59, 60, 61, 62, 63},
113 .oobfree = { {2, 38} }
114};
115
116/* This is used for padding purposes in nand_write_oob */
117static u_char ffchars[] = {
118 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
119 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
120 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
121 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
122 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
123 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
124 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
125 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
126};
127
128/*
129 * NAND low-level MTD interface functions
130 */
131static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len);
132static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len);
133static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len);
134
135static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
136static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
137 size_t * retlen, u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
138static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf);
139static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf);
140static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
141 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel);
142static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char *buf);
143/* XXX U-BOOT XXX */
144#if 0
145static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs,
146 unsigned long count, loff_t to, size_t * retlen);
147static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs,
148 unsigned long count, loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel);
149#endif
150static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
151static void nand_sync (struct mtd_info *mtd);
152
153/* Some internal functions */
154static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, u_char *oob_buf,
155 struct nand_oobinfo *oobsel, int mode);
156#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200157static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200158 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode);
159#else
160#define nand_verify_pages(...) (0)
161#endif
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200162
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200163static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state);
164
165/**
166 * nand_release_device - [GENERIC] release chip
167 * @mtd: MTD device structure
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200168 *
169 * Deselect, release chip lock and wake up anyone waiting on the device
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200170 */
171/* XXX U-BOOT XXX */
172#if 0
173static void nand_release_device (struct mtd_info *mtd)
174{
175 struct nand_chip *this = mtd->priv;
176
177 /* De-select the NAND device */
178 this->select_chip(mtd, -1);
179 /* Do we have a hardware controller ? */
180 if (this->controller) {
181 spin_lock(&this->controller->lock);
182 this->controller->active = NULL;
183 spin_unlock(&this->controller->lock);
184 }
185 /* Release the chip */
186 spin_lock (&this->chip_lock);
187 this->state = FL_READY;
188 wake_up (&this->wq);
189 spin_unlock (&this->chip_lock);
190}
191#else
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100192static void nand_release_device (struct mtd_info *mtd)
193{
194 struct nand_chip *this = mtd->priv;
195 this->select_chip(mtd, -1); /* De-select the NAND device */
196}
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200197#endif
198
199/**
200 * nand_read_byte - [DEFAULT] read one byte from the chip
201 * @mtd: MTD device structure
202 *
203 * Default read function for 8bit buswith
204 */
205static u_char nand_read_byte(struct mtd_info *mtd)
206{
207 struct nand_chip *this = mtd->priv;
208 return readb(this->IO_ADDR_R);
209}
210
211/**
212 * nand_write_byte - [DEFAULT] write one byte to the chip
213 * @mtd: MTD device structure
214 * @byte: pointer to data byte to write
215 *
216 * Default write function for 8it buswith
217 */
218static void nand_write_byte(struct mtd_info *mtd, u_char byte)
219{
220 struct nand_chip *this = mtd->priv;
221 writeb(byte, this->IO_ADDR_W);
222}
223
224/**
225 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
226 * @mtd: MTD device structure
227 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200228 * Default read function for 16bit buswith with
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200229 * endianess conversion
230 */
231static u_char nand_read_byte16(struct mtd_info *mtd)
232{
233 struct nand_chip *this = mtd->priv;
234 return (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
235}
236
237/**
238 * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
239 * @mtd: MTD device structure
240 * @byte: pointer to data byte to write
241 *
242 * Default write function for 16bit buswith with
243 * endianess conversion
244 */
245static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
246{
247 struct nand_chip *this = mtd->priv;
248 writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
249}
250
251/**
252 * nand_read_word - [DEFAULT] read one word from the chip
253 * @mtd: MTD device structure
254 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200255 * Default read function for 16bit buswith without
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200256 * endianess conversion
257 */
258static u16 nand_read_word(struct mtd_info *mtd)
259{
260 struct nand_chip *this = mtd->priv;
261 return readw(this->IO_ADDR_R);
262}
263
264/**
265 * nand_write_word - [DEFAULT] write one word to the chip
266 * @mtd: MTD device structure
267 * @word: data word to write
268 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200269 * Default write function for 16bit buswith without
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200270 * endianess conversion
271 */
272static void nand_write_word(struct mtd_info *mtd, u16 word)
273{
274 struct nand_chip *this = mtd->priv;
275 writew(word, this->IO_ADDR_W);
276}
277
278/**
279 * nand_select_chip - [DEFAULT] control CE line
280 * @mtd: MTD device structure
281 * @chip: chipnumber to select, -1 for deselect
282 *
283 * Default select function for 1 chip devices.
284 */
285static void nand_select_chip(struct mtd_info *mtd, int chip)
286{
287 struct nand_chip *this = mtd->priv;
288 switch(chip) {
289 case -1:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200290 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200291 break;
292 case 0:
293 this->hwcontrol(mtd, NAND_CTL_SETNCE);
294 break;
295
296 default:
297 BUG();
298 }
299}
300
301/**
302 * nand_write_buf - [DEFAULT] write buffer to chip
303 * @mtd: MTD device structure
304 * @buf: data buffer
305 * @len: number of bytes to write
306 *
307 * Default write function for 8bit buswith
308 */
309static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
310{
311 int i;
312 struct nand_chip *this = mtd->priv;
313
314 for (i=0; i<len; i++)
315 writeb(buf[i], this->IO_ADDR_W);
316}
317
318/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200319 * nand_read_buf - [DEFAULT] read chip data into buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200320 * @mtd: MTD device structure
321 * @buf: buffer to store date
322 * @len: number of bytes to read
323 *
324 * Default read function for 8bit buswith
325 */
326static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
327{
328 int i;
329 struct nand_chip *this = mtd->priv;
330
331 for (i=0; i<len; i++)
332 buf[i] = readb(this->IO_ADDR_R);
333}
334
335/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200336 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200337 * @mtd: MTD device structure
338 * @buf: buffer containing the data to compare
339 * @len: number of bytes to compare
340 *
341 * Default verify function for 8bit buswith
342 */
343static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
344{
345 int i;
346 struct nand_chip *this = mtd->priv;
347
348 for (i=0; i<len; i++)
349 if (buf[i] != readb(this->IO_ADDR_R))
350 return -EFAULT;
351
352 return 0;
353}
354
355/**
356 * nand_write_buf16 - [DEFAULT] write buffer to chip
357 * @mtd: MTD device structure
358 * @buf: data buffer
359 * @len: number of bytes to write
360 *
361 * Default write function for 16bit buswith
362 */
363static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
364{
365 int i;
366 struct nand_chip *this = mtd->priv;
367 u16 *p = (u16 *) buf;
368 len >>= 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200369
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200370 for (i=0; i<len; i++)
371 writew(p[i], this->IO_ADDR_W);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200372
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200373}
374
375/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200376 * nand_read_buf16 - [DEFAULT] read chip data into buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200377 * @mtd: MTD device structure
378 * @buf: buffer to store date
379 * @len: number of bytes to read
380 *
381 * Default read function for 16bit buswith
382 */
383static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
384{
385 int i;
386 struct nand_chip *this = mtd->priv;
387 u16 *p = (u16 *) buf;
388 len >>= 1;
389
390 for (i=0; i<len; i++)
391 p[i] = readw(this->IO_ADDR_R);
392}
393
394/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200395 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200396 * @mtd: MTD device structure
397 * @buf: buffer containing the data to compare
398 * @len: number of bytes to compare
399 *
400 * Default verify function for 16bit buswith
401 */
402static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
403{
404 int i;
405 struct nand_chip *this = mtd->priv;
406 u16 *p = (u16 *) buf;
407 len >>= 1;
408
409 for (i=0; i<len; i++)
410 if (p[i] != readw(this->IO_ADDR_R))
411 return -EFAULT;
412
413 return 0;
414}
415
416/**
417 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
418 * @mtd: MTD device structure
419 * @ofs: offset from device start
420 * @getchip: 0, if the chip is already selected
421 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200422 * Check, if the block is bad.
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200423 */
424static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
425{
426 int page, chipnr, res = 0;
427 struct nand_chip *this = mtd->priv;
428 u16 bad;
429
430 if (getchip) {
431 page = (int)(ofs >> this->page_shift);
432 chipnr = (int)(ofs >> this->chip_shift);
433
434 /* Grab the lock and see if the device is available */
435 nand_get_device (this, mtd, FL_READING);
436
437 /* Select the NAND device */
438 this->select_chip(mtd, chipnr);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200439 } else
440 page = (int) ofs;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200441
442 if (this->options & NAND_BUSWIDTH_16) {
443 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
444 bad = cpu_to_le16(this->read_word(mtd));
445 if (this->badblockpos & 0x1)
446 bad >>= 1;
447 if ((bad & 0xFF) != 0xff)
448 res = 1;
449 } else {
450 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
451 if (this->read_byte(mtd) != 0xff)
452 res = 1;
453 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200454
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200455 if (getchip) {
456 /* Deselect and wake up anyone waiting on the device */
457 nand_release_device(mtd);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200458 }
459
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200460 return res;
461}
462
463/**
464 * nand_default_block_markbad - [DEFAULT] mark a block bad
465 * @mtd: MTD device structure
466 * @ofs: offset from device start
467 *
468 * This is the default implementation, which can be overridden by
469 * a hardware specific driver.
470*/
471static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
472{
473 struct nand_chip *this = mtd->priv;
474 u_char buf[2] = {0, 0};
475 size_t retlen;
476 int block;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200477
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200478 /* Get block number */
479 block = ((int) ofs) >> this->bbt_erase_shift;
480 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
481
482 /* Do we have a flash based bad block table ? */
483 if (this->options & NAND_USE_FLASH_BBT)
484 return nand_update_bbt (mtd, ofs);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200485
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200486 /* We write two bytes, so we dont have to mess with 16 bit access */
487 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
488 return nand_write_oob (mtd, ofs , 2, &retlen, buf);
489}
490
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200491/**
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200492 * nand_check_wp - [GENERIC] check if the chip is write protected
493 * @mtd: MTD device structure
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200494 * Check, if the device is write protected
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200495 *
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200496 * The function expects, that the device is already selected
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200497 */
498static int nand_check_wp (struct mtd_info *mtd)
499{
500 struct nand_chip *this = mtd->priv;
501 /* Check the WP bit */
502 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200503 return (this->read_byte(mtd) & 0x80) ? 0 : 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200504}
Markus Klotzbücher27eba142006-03-06 15:04:25 +0100505
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200506/**
507 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
508 * @mtd: MTD device structure
509 * @ofs: offset from device start
510 * @getchip: 0, if the chip is already selected
511 * @allowbbt: 1, if its allowed to access the bbt area
512 *
513 * Check, if the block is bad. Either by reading the bad block table or
514 * calling of the scan function.
515 */
516static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
517{
518 struct nand_chip *this = mtd->priv;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200519
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200520 if (!this->bbt)
521 return this->block_bad(mtd, ofs, getchip);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200522
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200523 /* Return info from the table */
524 return nand_isbad_bbt (mtd, ofs, allowbbt);
525}
526
527/**
528 * nand_command - [DEFAULT] Send command to NAND device
529 * @mtd: MTD device structure
530 * @command: the command to be sent
531 * @column: the column address for this command, -1 if none
532 * @page_addr: the page address for this command, -1 if none
533 *
534 * Send command to NAND device. This function is used for small page
535 * devices (256/512 Bytes per page)
536 */
537static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
538{
539 register struct nand_chip *this = mtd->priv;
540
541 /* Begin command latch cycle */
542 this->hwcontrol(mtd, NAND_CTL_SETCLE);
543 /*
544 * Write out the command to the device.
545 */
546 if (command == NAND_CMD_SEQIN) {
547 int readcmd;
548
549 if (column >= mtd->oobblock) {
550 /* OOB area */
551 column -= mtd->oobblock;
552 readcmd = NAND_CMD_READOOB;
553 } else if (column < 256) {
554 /* First 256 bytes --> READ0 */
555 readcmd = NAND_CMD_READ0;
556 } else {
557 column -= 256;
558 readcmd = NAND_CMD_READ1;
559 }
560 this->write_byte(mtd, readcmd);
561 }
562 this->write_byte(mtd, command);
563
564 /* Set ALE and clear CLE to start address cycle */
565 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
566
567 if (column != -1 || page_addr != -1) {
568 this->hwcontrol(mtd, NAND_CTL_SETALE);
569
570 /* Serially input address */
571 if (column != -1) {
572 /* Adjust columns for 16 bit buswidth */
573 if (this->options & NAND_BUSWIDTH_16)
574 column >>= 1;
575 this->write_byte(mtd, column);
576 }
577 if (page_addr != -1) {
578 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
579 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
580 /* One more address cycle for devices > 32MiB */
581 if (this->chipsize > (32 << 20))
582 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
583 }
584 /* Latch in address */
585 this->hwcontrol(mtd, NAND_CTL_CLRALE);
586 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200587
588 /*
589 * program and erase have their own busy handlers
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200590 * status and sequential in needs no delay
591 */
592 switch (command) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200593
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200594 case NAND_CMD_PAGEPROG:
595 case NAND_CMD_ERASE1:
596 case NAND_CMD_ERASE2:
597 case NAND_CMD_SEQIN:
598 case NAND_CMD_STATUS:
599 return;
600
601 case NAND_CMD_RESET:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200602 if (this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200603 break;
604 udelay(this->chip_delay);
605 this->hwcontrol(mtd, NAND_CTL_SETCLE);
606 this->write_byte(mtd, NAND_CMD_STATUS);
607 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
608 while ( !(this->read_byte(mtd) & 0x40));
609 return;
610
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200611 /* This applies to read commands */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200612 default:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200613 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200614 * If we don't have access to the busy pin, we apply the given
615 * command delay
616 */
617 if (!this->dev_ready) {
618 udelay (this->chip_delay);
619 return;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200620 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200621 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200622
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200623 /* Apply this short delay always to ensure that we do wait tWB in
624 * any case on any machine. */
625 ndelay (100);
626 /* wait until command is processed */
627 while (!this->dev_ready(mtd));
628}
629
630/**
631 * nand_command_lp - [DEFAULT] Send command to NAND large page device
632 * @mtd: MTD device structure
633 * @command: the command to be sent
634 * @column: the column address for this command, -1 if none
635 * @page_addr: the page address for this command, -1 if none
636 *
637 * Send command to NAND device. This is the version for the new large page devices
638 * We dont have the seperate regions as we have in the small page devices.
639 * We must emulate NAND_CMD_READOOB to keep the code compatible.
640 *
641 */
642static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr)
643{
644 register struct nand_chip *this = mtd->priv;
645
646 /* Emulate NAND_CMD_READOOB */
647 if (command == NAND_CMD_READOOB) {
648 column += mtd->oobblock;
649 command = NAND_CMD_READ0;
650 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200651
652
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200653 /* Begin command latch cycle */
654 this->hwcontrol(mtd, NAND_CTL_SETCLE);
655 /* Write out the command to the device. */
656 this->write_byte(mtd, command);
657 /* End command latch cycle */
658 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
659
660 if (column != -1 || page_addr != -1) {
661 this->hwcontrol(mtd, NAND_CTL_SETALE);
662
663 /* Serially input address */
664 if (column != -1) {
665 /* Adjust columns for 16 bit buswidth */
666 if (this->options & NAND_BUSWIDTH_16)
667 column >>= 1;
668 this->write_byte(mtd, column & 0xff);
669 this->write_byte(mtd, column >> 8);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200670 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200671 if (page_addr != -1) {
672 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
673 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
674 /* One more address cycle for devices > 128MiB */
675 if (this->chipsize > (128 << 20))
676 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff));
677 }
678 /* Latch in address */
679 this->hwcontrol(mtd, NAND_CTL_CLRALE);
680 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200681
682 /*
683 * program and erase have their own busy handlers
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200684 * status and sequential in needs no delay
685 */
686 switch (command) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200687
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200688 case NAND_CMD_CACHEDPROG:
689 case NAND_CMD_PAGEPROG:
690 case NAND_CMD_ERASE1:
691 case NAND_CMD_ERASE2:
692 case NAND_CMD_SEQIN:
693 case NAND_CMD_STATUS:
694 return;
695
696
697 case NAND_CMD_RESET:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200698 if (this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200699 break;
700 udelay(this->chip_delay);
701 this->hwcontrol(mtd, NAND_CTL_SETCLE);
702 this->write_byte(mtd, NAND_CMD_STATUS);
703 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
704 while ( !(this->read_byte(mtd) & 0x40));
705 return;
706
707 case NAND_CMD_READ0:
708 /* Begin command latch cycle */
709 this->hwcontrol(mtd, NAND_CTL_SETCLE);
710 /* Write out the start read command */
711 this->write_byte(mtd, NAND_CMD_READSTART);
712 /* End command latch cycle */
713 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
714 /* Fall through into ready check */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200715
716 /* This applies to read commands */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200717 default:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200718 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200719 * If we don't have access to the busy pin, we apply the given
720 * command delay
721 */
722 if (!this->dev_ready) {
723 udelay (this->chip_delay);
724 return;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200725 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200726 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200727
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200728 /* Apply this short delay always to ensure that we do wait tWB in
729 * any case on any machine. */
730 ndelay (100);
731 /* wait until command is processed */
732 while (!this->dev_ready(mtd));
733}
734
735/**
736 * nand_get_device - [GENERIC] Get chip for selected access
737 * @this: the nand chip descriptor
738 * @mtd: MTD device structure
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200739 * @new_state: the state which is requested
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200740 *
741 * Get the device and lock it for exclusive access
742 */
743/* XXX U-BOOT XXX */
744#if 0
745static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state)
746{
747 struct nand_chip *active = this;
748
749 DECLARE_WAITQUEUE (wait, current);
750
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200751 /*
752 * Grab the lock and see if the device is available
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200753 */
754retry:
755 /* Hardware controller shared among independend devices */
756 if (this->controller) {
757 spin_lock (&this->controller->lock);
758 if (this->controller->active)
759 active = this->controller->active;
760 else
761 this->controller->active = this;
762 spin_unlock (&this->controller->lock);
763 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200764
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200765 if (active == this) {
766 spin_lock (&this->chip_lock);
767 if (this->state == FL_READY) {
768 this->state = new_state;
769 spin_unlock (&this->chip_lock);
770 return;
771 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200772 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200773 set_current_state (TASK_UNINTERRUPTIBLE);
774 add_wait_queue (&active->wq, &wait);
775 spin_unlock (&active->chip_lock);
776 schedule ();
777 remove_wait_queue (&active->wq, &wait);
778 goto retry;
779}
780#else
781static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state) {}
782#endif
783
784/**
785 * nand_wait - [DEFAULT] wait until the command is done
786 * @mtd: MTD device structure
787 * @this: NAND chip structure
788 * @state: state to select the max. timeout value
789 *
790 * Wait for command done. This applies to erase and program only
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200791 * Erase can take up to 400ms and program up to 20ms according to
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200792 * general NAND and SmartMedia specs
793 *
794*/
795/* XXX U-BOOT XXX */
796#if 0
797static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
798{
799 unsigned long timeo = jiffies;
800 int status;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200801
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200802 if (state == FL_ERASING)
803 timeo += (HZ * 400) / 1000;
804 else
805 timeo += (HZ * 20) / 1000;
806
807 /* Apply this short delay always to ensure that we do wait tWB in
808 * any case on any machine. */
809 ndelay (100);
810
811 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
812 this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200813 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200814 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
815
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200816 while (time_before(jiffies, timeo)) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200817 /* Check, if we were interrupted */
818 if (this->state != state)
819 return 0;
820
821 if (this->dev_ready) {
822 if (this->dev_ready(mtd))
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200823 break;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200824 } else {
825 if (this->read_byte(mtd) & NAND_STATUS_READY)
826 break;
827 }
828 yield ();
829 }
830 status = (int) this->read_byte(mtd);
831 return status;
832
833 return 0;
834}
835#else
836static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
837{
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100838 unsigned long timeo;
839
840 if (state == FL_ERASING)
Stefan Roese3427cf62006-11-28 11:04:45 +0100841 timeo = (CFG_HZ * 400) / 1000;
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100842 else
Stefan Roese3427cf62006-11-28 11:04:45 +0100843 timeo = (CFG_HZ * 20) / 1000;
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100844
845 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
846 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
847 else
848 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
849
Bartlomiej Sieka6eed2ab2006-02-24 09:37:22 +0100850 reset_timer();
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100851
852 while (1) {
Bartlomiej Sieka6eed2ab2006-02-24 09:37:22 +0100853 if (get_timer(0) > timeo) {
854 printf("Timeout!");
Stefan Roeseef26d242006-11-27 17:22:19 +0100855 return 0x01;
856 }
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100857
858 if (this->dev_ready) {
859 if (this->dev_ready(mtd))
860 break;
861 } else {
862 if (this->read_byte(mtd) & NAND_STATUS_READY)
863 break;
864 }
865 }
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100866#ifdef PPCHAMELON_NAND_TIMER_HACK
Bartlomiej Sieka6eed2ab2006-02-24 09:37:22 +0100867 reset_timer();
868 while (get_timer(0) < 10);
Bartlomiej Sieka582f1a32006-03-05 18:57:33 +0100869#endif /* PPCHAMELON_NAND_TIMER_HACK */
Bartlomiej Sieka6eed2ab2006-02-24 09:37:22 +0100870
Wolfgang Denk9a08dd12005-11-02 14:29:12 +0100871 return this->read_byte(mtd);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200872}
873#endif
874
875/**
876 * nand_write_page - [GENERIC] write one page
877 * @mtd: MTD device structure
878 * @this: NAND chip structure
879 * @page: startpage inside the chip, must be called with (page & this->pagemask)
880 * @oob_buf: out of band data buffer
881 * @oobsel: out of band selecttion structre
882 * @cached: 1 = enable cached programming if supported by chip
883 *
884 * Nand_page_program function is used for write and writev !
885 * This function will always program a full page of data
886 * If you call it with a non page aligned buffer, you're lost :)
887 *
888 * Cached programming is not supported yet.
889 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200890static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200891 u_char *oob_buf, struct nand_oobinfo *oobsel, int cached)
892{
893 int i, status;
894 u_char ecc_code[32];
895 int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
Wolfgang Denk7fa6e902006-03-11 22:53:33 +0100896 uint *oob_config = oobsel->eccpos;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200897 int datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
898 int eccbytes = 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200899
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200900 /* FIXME: Enable cached programming */
901 cached = 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200902
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200903 /* Send command to begin auto page programming */
904 this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
905
906 /* Write out complete page of data, take care of eccmode */
907 switch (eccmode) {
908 /* No ecc, write all */
909 case NAND_ECC_NONE:
910 printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
911 this->write_buf(mtd, this->data_poi, mtd->oobblock);
912 break;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200913
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200914 /* Software ecc 3/256, write all */
915 case NAND_ECC_SOFT:
916 for (; eccsteps; eccsteps--) {
917 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
918 for (i = 0; i < 3; i++, eccidx++)
919 oob_buf[oob_config[eccidx]] = ecc_code[i];
920 datidx += this->eccsize;
921 }
922 this->write_buf(mtd, this->data_poi, mtd->oobblock);
923 break;
924 default:
925 eccbytes = this->eccbytes;
926 for (; eccsteps; eccsteps--) {
927 /* enable hardware ecc logic for write */
928 this->enable_hwecc(mtd, NAND_ECC_WRITE);
929 this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
930 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
931 for (i = 0; i < eccbytes; i++, eccidx++)
932 oob_buf[oob_config[eccidx]] = ecc_code[i];
933 /* If the hardware ecc provides syndromes then
934 * the ecc code must be written immidiately after
935 * the data bytes (words) */
936 if (this->options & NAND_HWECC_SYNDROME)
937 this->write_buf(mtd, ecc_code, eccbytes);
938 datidx += this->eccsize;
939 }
940 break;
941 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200942
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200943 /* Write out OOB data */
944 if (this->options & NAND_HWECC_SYNDROME)
945 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200946 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200947 this->write_buf(mtd, oob_buf, mtd->oobsize);
948
949 /* Send command to actually program the data */
950 this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
951
952 if (!cached) {
953 /* call wait ready function */
954 status = this->waitfunc (mtd, this, FL_WRITING);
955 /* See if device thinks it succeeded */
956 if (status & 0x01) {
957 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
958 return -EIO;
959 }
960 } else {
961 /* FIXME: Implement cached programming ! */
962 /* wait until cache is ready*/
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200963 /* status = this->waitfunc (mtd, this, FL_CACHEDRPG); */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200964 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200965 return 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200966}
967
968#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
969/**
970 * nand_verify_pages - [GENERIC] verify the chip contents after a write
971 * @mtd: MTD device structure
972 * @this: NAND chip structure
973 * @page: startpage inside the chip, must be called with (page & this->pagemask)
974 * @numpages: number of pages to verify
975 * @oob_buf: out of band data buffer
976 * @oobsel: out of band selecttion structre
977 * @chipnr: number of the current chip
978 * @oobmode: 1 = full buffer verify, 0 = ecc only
979 *
980 * The NAND device assumes that it is always writing to a cleanly erased page.
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200981 * Hence, it performs its internal write verification only on bits that
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200982 * transitioned from 1 to 0. The device does NOT verify the whole page on a
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200983 * byte by byte basis. It is possible that the page was not completely erased
984 * or the page is becoming unusable due to wear. The read with ECC would catch
985 * the error later when the ECC page check fails, but we would rather catch
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200986 * it early in the page write stage. Better to write no data than invalid data.
987 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200988static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200989 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
990{
991 int i, j, datidx = 0, oobofs = 0, res = -EIO;
992 int eccsteps = this->eccsteps;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +0200993 int hweccbytes;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +0200994 u_char oobdata[64];
995
996 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
997
998 /* Send command to read back the first page */
999 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page);
1000
1001 for(;;) {
1002 for (j = 0; j < eccsteps; j++) {
1003 /* Loop through and verify the data */
1004 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
1005 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1006 goto out;
1007 }
1008 datidx += mtd->eccsize;
1009 /* Have we a hw generator layout ? */
1010 if (!hweccbytes)
1011 continue;
1012 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
1013 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1014 goto out;
1015 }
1016 oobofs += hweccbytes;
1017 }
1018
1019 /* check, if we must compare all data or if we just have to
1020 * compare the ecc bytes
1021 */
1022 if (oobmode) {
1023 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
1024 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1025 goto out;
1026 }
1027 } else {
1028 /* Read always, else autoincrement fails */
1029 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
1030
1031 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
1032 int ecccnt = oobsel->eccbytes;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001033
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001034 for (i = 0; i < ecccnt; i++) {
1035 int idx = oobsel->eccpos[i];
1036 if (oobdata[idx] != oob_buf[oobofs + idx] ) {
1037 DEBUG (MTD_DEBUG_LEVEL0,
1038 "%s: Failed ECC write "
1039 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
1040 goto out;
1041 }
1042 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001043 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001044 }
1045 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1046 page++;
1047 numpages--;
1048
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001049 /* Apply delay or wait for ready/busy pin
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001050 * Do this before the AUTOINCR check, so no problems
1051 * arise if a chip which does auto increment
1052 * is marked as NOAUTOINCR by the board driver.
1053 * Do this also before returning, so the chip is
1054 * ready for the next command.
1055 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001056 if (!this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001057 udelay (this->chip_delay);
1058 else
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001059 while (!this->dev_ready(mtd));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001060
1061 /* All done, return happy */
1062 if (!numpages)
1063 return 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001064
1065
1066 /* Check, if the chip supports auto page increment */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001067 if (!NAND_CANAUTOINCR(this))
1068 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1069 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001070 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001071 * Terminate the read command. We come here in case of an error
1072 * So we must issue a reset command.
1073 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001074out:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001075 this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1);
1076 return res;
1077}
1078#endif
1079
1080/**
1081 * nand_read - [MTD Interface] MTD compability function for nand_read_ecc
1082 * @mtd: MTD device structure
1083 * @from: offset to read from
1084 * @len: number of bytes to read
1085 * @retlen: pointer to variable to store the number of read bytes
1086 * @buf: the databuffer to put data
1087 *
1088 * This function simply calls nand_read_ecc with oob buffer and oobsel = NULL
1089*/
1090static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1091{
1092 return nand_read_ecc (mtd, from, len, retlen, buf, NULL, NULL);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001093}
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001094
1095
1096/**
1097 * nand_read_ecc - [MTD Interface] Read data with ECC
1098 * @mtd: MTD device structure
1099 * @from: offset to read from
1100 * @len: number of bytes to read
1101 * @retlen: pointer to variable to store the number of read bytes
1102 * @buf: the databuffer to put data
1103 * @oob_buf: filesystem supplied oob data buffer
1104 * @oobsel: oob selection structure
1105 *
1106 * NAND read with ECC
1107 */
1108static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1109 size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
1110{
1111 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1112 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1113 struct nand_chip *this = mtd->priv;
1114 u_char *data_poi, *oob_data = oob_buf;
1115 u_char ecc_calc[32];
1116 u_char ecc_code[32];
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001117 int eccmode, eccsteps;
Wolfgang Denk7fa6e902006-03-11 22:53:33 +01001118 unsigned *oob_config;
1119 int datidx;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001120 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1121 int eccbytes;
1122 int compareecc = 1;
1123 int oobreadlen;
1124
1125
1126 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1127
1128 /* Do not allow reads past end of device */
1129 if ((from + len) > mtd->size) {
1130 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1131 *retlen = 0;
1132 return -EINVAL;
1133 }
1134
1135 /* Grab the lock and see if the device is available */
1136 nand_get_device (this, mtd ,FL_READING);
1137
1138 /* use userspace supplied oobinfo, if zero */
1139 if (oobsel == NULL)
1140 oobsel = &mtd->oobinfo;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001141
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001142 /* Autoplace of oob data ? Use the default placement scheme */
1143 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1144 oobsel = this->autooob;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001145
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001146 eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
1147 oob_config = oobsel->eccpos;
1148
1149 /* Select the NAND device */
1150 chipnr = (int)(from >> this->chip_shift);
1151 this->select_chip(mtd, chipnr);
1152
1153 /* First we calculate the starting page */
1154 realpage = (int) (from >> this->page_shift);
1155 page = realpage & this->pagemask;
1156
1157 /* Get raw starting column */
1158 col = from & (mtd->oobblock - 1);
1159
1160 end = mtd->oobblock;
1161 ecc = this->eccsize;
1162 eccbytes = this->eccbytes;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001163
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001164 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1165 compareecc = 0;
1166
1167 oobreadlen = mtd->oobsize;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001168 if (this->options & NAND_HWECC_SYNDROME)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001169 oobreadlen -= oobsel->eccbytes;
1170
1171 /* Loop until all data read */
1172 while (read < len) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001173
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001174 int aligned = (!col && (len - read) >= end);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001175 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001176 * If the read is not page aligned, we have to read into data buffer
1177 * due to ecc, else we read into return buffer direct
1178 */
1179 if (aligned)
1180 data_poi = &buf[read];
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001181 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001182 data_poi = this->data_buf;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001183
1184 /* Check, if we have this page in the buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001185 *
1186 * FIXME: Make it work when we must provide oob data too,
1187 * check the usage of data_buf oob field
1188 */
1189 if (realpage == this->pagebuf && !oob_buf) {
1190 /* aligned read ? */
1191 if (aligned)
1192 memcpy (data_poi, this->data_buf, end);
1193 goto readdata;
1194 }
1195
1196 /* Check, if we must send the read command */
1197 if (sndcmd) {
1198 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1199 sndcmd = 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001200 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001201
1202 /* get oob area, if we have no oob buffer from fs-driver */
1203 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1204 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1205 oob_data = &this->data_buf[end];
1206
1207 eccsteps = this->eccsteps;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001208
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001209 switch (eccmode) {
1210 case NAND_ECC_NONE: { /* No ECC, Read in a page */
1211/* XXX U-BOOT XXX */
1212#if 0
1213 static unsigned long lastwhinge = 0;
1214 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1215 printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
1216 lastwhinge = jiffies;
1217 }
1218#else
1219 puts("Reading data from NAND FLASH without ECC is not recommended\n");
1220#endif
1221 this->read_buf(mtd, data_poi, end);
1222 break;
1223 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001224
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001225 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1226 this->read_buf(mtd, data_poi, end);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001227 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001228 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001229 break;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001230
1231 default:
1232 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
1233 this->enable_hwecc(mtd, NAND_ECC_READ);
1234 this->read_buf(mtd, &data_poi[datidx], ecc);
1235
1236 /* HW ecc with syndrome calculation must read the
1237 * syndrome from flash immidiately after the data */
1238 if (!compareecc) {
1239 /* Some hw ecc generators need to know when the
1240 * syndrome is read from flash */
1241 this->enable_hwecc(mtd, NAND_ECC_READSYN);
1242 this->read_buf(mtd, &oob_data[i], eccbytes);
1243 /* We calc error correction directly, it checks the hw
1244 * generator for an error, reads back the syndrome and
1245 * does the error correction on the fly */
1246 if (this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]) == -1) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001247 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001248 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1249 ecc_failed++;
1250 }
1251 } else {
1252 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001253 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001254 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001255 break;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001256 }
1257
1258 /* read oobdata */
1259 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1260
1261 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1262 if (!compareecc)
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001263 goto readoob;
1264
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001265 /* Pick the ECC bytes out of the oob data */
1266 for (j = 0; j < oobsel->eccbytes; j++)
1267 ecc_code[j] = oob_data[oob_config[j]];
1268
1269 /* correct data, if neccecary */
1270 for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
1271 ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001272
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001273 /* Get next chunk of ecc bytes */
1274 j += eccbytes;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001275
1276 /* Check, if we have a fs supplied oob-buffer,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001277 * This is the legacy mode. Used by YAFFS1
1278 * Should go away some day
1279 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001280 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001281 int *p = (int *)(&oob_data[mtd->oobsize]);
1282 p[i] = ecc_status;
1283 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001284
1285 if (ecc_status == -1) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001286 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1287 ecc_failed++;
1288 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001289 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001290
1291 readoob:
1292 /* check, if we have a fs supplied oob-buffer */
1293 if (oob_buf) {
1294 /* without autoplace. Legacy mode used by YAFFS1 */
1295 switch(oobsel->useecc) {
1296 case MTD_NANDECC_AUTOPLACE:
1297 case MTD_NANDECC_AUTOPL_USR:
1298 /* Walk through the autoplace chunks */
1299 for (i = 0, j = 0; j < mtd->oobavail; i++) {
1300 int from = oobsel->oobfree[i][0];
1301 int num = oobsel->oobfree[i][1];
1302 memcpy(&oob_buf[oob], &oob_data[from], num);
1303 j+= num;
1304 }
1305 oob += mtd->oobavail;
1306 break;
1307 case MTD_NANDECC_PLACE:
1308 /* YAFFS1 legacy mode */
1309 oob_data += this->eccsteps * sizeof (int);
1310 default:
1311 oob_data += mtd->oobsize;
1312 }
1313 }
1314 readdata:
1315 /* Partial page read, transfer data into fs buffer */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001316 if (!aligned) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001317 for (j = col; j < end && read < len; j++)
1318 buf[read++] = data_poi[j];
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001319 this->pagebuf = realpage;
1320 } else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001321 read += mtd->oobblock;
1322
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001323 /* Apply delay or wait for ready/busy pin
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001324 * Do this before the AUTOINCR check, so no problems
1325 * arise if a chip which does auto increment
1326 * is marked as NOAUTOINCR by the board driver.
1327 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001328 if (!this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001329 udelay (this->chip_delay);
1330 else
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001331 while (!this->dev_ready(mtd));
1332
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001333 if (read == len)
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001334 break;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001335
1336 /* For subsequent reads align to page boundary. */
1337 col = 0;
1338 /* Increment page address */
1339 realpage++;
1340
1341 page = realpage & this->pagemask;
1342 /* Check, if we cross a chip boundary */
1343 if (!page) {
1344 chipnr++;
1345 this->select_chip(mtd, -1);
1346 this->select_chip(mtd, chipnr);
1347 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001348 /* Check, if the chip supports auto page increment
1349 * or if we have hit a block boundary.
1350 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001351 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001352 sndcmd = 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001353 }
1354
1355 /* Deselect and wake up anyone waiting on the device */
1356 nand_release_device(mtd);
1357
1358 /*
1359 * Return success, if no ECC failures, else -EBADMSG
1360 * fs driver will take care of that, because
1361 * retlen == desired len and result == -EBADMSG
1362 */
1363 *retlen = read;
1364 return ecc_failed ? -EBADMSG : 0;
1365}
1366
1367/**
1368 * nand_read_oob - [MTD Interface] NAND read out-of-band
1369 * @mtd: MTD device structure
1370 * @from: offset to read from
1371 * @len: number of bytes to read
1372 * @retlen: pointer to variable to store the number of read bytes
1373 * @buf: the databuffer to put data
1374 *
1375 * NAND read out-of-band data from the spare area
1376 */
1377static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1378{
1379 int i, col, page, chipnr;
1380 struct nand_chip *this = mtd->priv;
1381 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1382
1383 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1384
1385 /* Shift to get page */
1386 page = (int)(from >> this->page_shift);
1387 chipnr = (int)(from >> this->chip_shift);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001388
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001389 /* Mask to get column */
1390 col = from & (mtd->oobsize - 1);
1391
1392 /* Initialize return length value */
1393 *retlen = 0;
1394
1395 /* Do not allow reads past end of device */
1396 if ((from + len) > mtd->size) {
1397 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1398 *retlen = 0;
1399 return -EINVAL;
1400 }
1401
1402 /* Grab the lock and see if the device is available */
1403 nand_get_device (this, mtd , FL_READING);
1404
1405 /* Select the NAND device */
1406 this->select_chip(mtd, chipnr);
1407
1408 /* Send the read command */
1409 this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001410 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001411 * Read the data, if we read more than one page
1412 * oob data, let the device transfer the data !
1413 */
1414 i = 0;
1415 while (i < len) {
1416 int thislen = mtd->oobsize - col;
1417 thislen = min_t(int, thislen, len);
1418 this->read_buf(mtd, &buf[i], thislen);
1419 i += thislen;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001420
1421 /* Apply delay or wait for ready/busy pin
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001422 * Do this before the AUTOINCR check, so no problems
1423 * arise if a chip which does auto increment
1424 * is marked as NOAUTOINCR by the board driver.
1425 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001426 if (!this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001427 udelay (this->chip_delay);
1428 else
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001429 while (!this->dev_ready(mtd));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001430
1431 /* Read more ? */
1432 if (i < len) {
1433 page++;
1434 col = 0;
1435
1436 /* Check, if we cross a chip boundary */
1437 if (!(page & this->pagemask)) {
1438 chipnr++;
1439 this->select_chip(mtd, -1);
1440 this->select_chip(mtd, chipnr);
1441 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001442
1443 /* Check, if the chip supports auto page increment
1444 * or if we have hit a block boundary.
1445 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001446 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1447 /* For subsequent page reads set offset to 0 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001448 this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001449 }
1450 }
1451 }
1452
1453 /* Deselect and wake up anyone waiting on the device */
1454 nand_release_device(mtd);
1455
1456 /* Return happy */
1457 *retlen = len;
1458 return 0;
1459}
1460
1461/**
1462 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1463 * @mtd: MTD device structure
1464 * @buf: temporary buffer
1465 * @from: offset to read from
1466 * @len: number of bytes to read
1467 * @ooblen: number of oob data bytes to read
1468 *
1469 * Read raw data including oob into buffer
1470 */
1471int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1472{
1473 struct nand_chip *this = mtd->priv;
1474 int page = (int) (from >> this->page_shift);
1475 int chip = (int) (from >> this->chip_shift);
1476 int sndcmd = 1;
1477 int cnt = 0;
1478 int pagesize = mtd->oobblock + mtd->oobsize;
1479 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1480
1481 /* Do not allow reads past end of device */
1482 if ((from + len) > mtd->size) {
1483 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1484 return -EINVAL;
1485 }
1486
1487 /* Grab the lock and see if the device is available */
1488 nand_get_device (this, mtd , FL_READING);
1489
1490 this->select_chip (mtd, chip);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001491
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001492 /* Add requested oob length */
1493 len += ooblen;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001494
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001495 while (len) {
1496 if (sndcmd)
1497 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001498 sndcmd = 0;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001499
1500 this->read_buf (mtd, &buf[cnt], pagesize);
1501
1502 len -= pagesize;
1503 cnt += pagesize;
1504 page++;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001505
1506 if (!this->dev_ready)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001507 udelay (this->chip_delay);
1508 else
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001509 while (!this->dev_ready(mtd));
1510
1511 /* Check, if the chip supports auto page increment */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001512 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1513 sndcmd = 1;
1514 }
1515
1516 /* Deselect and wake up anyone waiting on the device */
1517 nand_release_device(mtd);
1518 return 0;
1519}
1520
1521
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001522/**
1523 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001524 * @mtd: MTD device structure
1525 * @fsbuf: buffer given by fs driver
1526 * @oobsel: out of band selection structre
1527 * @autoplace: 1 = place given buffer into the oob bytes
1528 * @numpages: number of pages to prepare
1529 *
1530 * Return:
1531 * 1. Filesystem buffer available and autoplacement is off,
1532 * return filesystem buffer
1533 * 2. No filesystem buffer or autoplace is off, return internal
1534 * buffer
1535 * 3. Filesystem buffer is given and autoplace selected
1536 * put data from fs buffer into internal buffer and
1537 * retrun internal buffer
1538 *
1539 * Note: The internal buffer is filled with 0xff. This must
1540 * be done only once, when no autoplacement happens
1541 * Autoplacement sets the buffer dirty flag, which
1542 * forces the 0xff fill before using the buffer again.
1543 *
1544*/
1545static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
1546 int autoplace, int numpages)
1547{
1548 struct nand_chip *this = mtd->priv;
1549 int i, len, ofs;
1550
1551 /* Zero copy fs supplied buffer */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001552 if (fsbuf && !autoplace)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001553 return fsbuf;
1554
1555 /* Check, if the buffer must be filled with ff again */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001556 if (this->oobdirty) {
1557 memset (this->oob_buf, 0xff,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001558 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1559 this->oobdirty = 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001560 }
1561
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001562 /* If we have no autoplacement or no fs buffer use the internal one */
1563 if (!autoplace || !fsbuf)
1564 return this->oob_buf;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001565
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001566 /* Walk through the pages and place the data */
1567 this->oobdirty = 1;
1568 ofs = 0;
1569 while (numpages--) {
1570 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1571 int to = ofs + oobsel->oobfree[i][0];
1572 int num = oobsel->oobfree[i][1];
1573 memcpy (&this->oob_buf[to], fsbuf, num);
1574 len += num;
1575 fsbuf += num;
1576 }
1577 ofs += mtd->oobavail;
1578 }
1579 return this->oob_buf;
1580}
1581
1582#define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
1583
1584/**
1585 * nand_write - [MTD Interface] compability function for nand_write_ecc
1586 * @mtd: MTD device structure
1587 * @to: offset to write to
1588 * @len: number of bytes to write
1589 * @retlen: pointer to variable to store the number of written bytes
1590 * @buf: the data to write
1591 *
1592 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1593 *
1594*/
1595static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1596{
1597 return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
1598}
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001599
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001600/**
1601 * nand_write_ecc - [MTD Interface] NAND write with ECC
1602 * @mtd: MTD device structure
1603 * @to: offset to write to
1604 * @len: number of bytes to write
1605 * @retlen: pointer to variable to store the number of written bytes
1606 * @buf: the data to write
1607 * @eccbuf: filesystem supplied oob data buffer
1608 * @oobsel: oob selection structure
1609 *
1610 * NAND write with ECC
1611 */
1612static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1613 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel)
1614{
1615 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1616 int autoplace = 0, numpages, totalpages;
1617 struct nand_chip *this = mtd->priv;
1618 u_char *oobbuf, *bufstart;
1619 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1620
1621 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1622
1623 /* Initialize retlen, in case of early exit */
1624 *retlen = 0;
1625
1626 /* Do not allow write past end of device */
1627 if ((to + len) > mtd->size) {
1628 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
1629 return -EINVAL;
1630 }
1631
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001632 /* reject writes, which are not page aligned */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001633 if (NOTALIGNED (to) || NOTALIGNED(len)) {
1634 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1635 return -EINVAL;
1636 }
1637
1638 /* Grab the lock and see if the device is available */
1639 nand_get_device (this, mtd, FL_WRITING);
1640
1641 /* Calculate chipnr */
1642 chipnr = (int)(to >> this->chip_shift);
1643 /* Select the NAND device */
1644 this->select_chip(mtd, chipnr);
1645
1646 /* Check, if it is write protected */
1647 if (nand_check_wp(mtd))
1648 goto out;
1649
1650 /* if oobsel is NULL, use chip defaults */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001651 if (oobsel == NULL)
1652 oobsel = &mtd->oobinfo;
1653
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001654 /* Autoplace of oob data ? Use the default placement scheme */
1655 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1656 oobsel = this->autooob;
1657 autoplace = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001658 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001659 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1660 autoplace = 1;
1661
1662 /* Setup variables and oob buffer */
1663 totalpages = len >> this->page_shift;
1664 page = (int) (to >> this->page_shift);
1665 /* Invalidate the page cache, if we write to the cached page */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001666 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001667 this->pagebuf = -1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001668
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001669 /* Set it relative to chip */
1670 page &= this->pagemask;
1671 startpage = page;
1672 /* Calc number of pages we can write in one go */
1673 numpages = min (ppblock - (startpage & (ppblock - 1)), totalpages);
1674 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages);
1675 bufstart = (u_char *)buf;
1676
1677 /* Loop until all data is written */
1678 while (written < len) {
1679
1680 this->data_poi = (u_char*) &buf[written];
1681 /* Write one page. If this is the last page to write
1682 * or the last page in this block, then use the
1683 * real pageprogram command, else select cached programming
1684 * if supported by the chip.
1685 */
1686 ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1687 if (ret) {
1688 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1689 goto out;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001690 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001691 /* Next oob page */
1692 oob += mtd->oobsize;
1693 /* Update written bytes count */
1694 written += mtd->oobblock;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001695 if (written == len)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001696 goto cmp;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001697
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001698 /* Increment page address */
1699 page++;
1700
1701 /* Have we hit a block boundary ? Then we have to verify and
1702 * if verify is ok, we have to setup the oob buffer for
1703 * the next pages.
1704 */
1705 if (!(page & (ppblock - 1))){
1706 int ofs;
1707 this->data_poi = bufstart;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001708 ret = nand_verify_pages (mtd, this, startpage,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001709 page - startpage,
1710 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1711 if (ret) {
1712 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1713 goto out;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001714 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001715 *retlen = written;
Nick Spence20362002006-09-30 00:32:59 -07001716 bufstart = (u_char*) &buf[written];
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001717
1718 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1719 if (eccbuf)
1720 eccbuf += (page - startpage) * ofs;
1721 totalpages -= page - startpage;
1722 numpages = min (totalpages, ppblock);
1723 page &= this->pagemask;
1724 startpage = page;
Markus Klotzbücher85678e22006-03-06 13:45:42 +01001725 oob = 0;
1726 this->oobdirty = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001727 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001728 autoplace, numpages);
1729 /* Check, if we cross a chip boundary */
1730 if (!page) {
1731 chipnr++;
1732 this->select_chip(mtd, -1);
1733 this->select_chip(mtd, chipnr);
1734 }
1735 }
1736 }
1737 /* Verify the remaining pages */
1738cmp:
1739 this->data_poi = bufstart;
1740 ret = nand_verify_pages (mtd, this, startpage, totalpages,
1741 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1742 if (!ret)
1743 *retlen = written;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001744 else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001745 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1746
1747out:
1748 /* Deselect and wake up anyone waiting on the device */
1749 nand_release_device(mtd);
1750
1751 return ret;
1752}
1753
1754
1755/**
1756 * nand_write_oob - [MTD Interface] NAND write out-of-band
1757 * @mtd: MTD device structure
1758 * @to: offset to write to
1759 * @len: number of bytes to write
1760 * @retlen: pointer to variable to store the number of written bytes
1761 * @buf: the data to write
1762 *
1763 * NAND write out-of-band
1764 */
1765static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1766{
1767 int column, page, status, ret = -EIO, chipnr;
1768 struct nand_chip *this = mtd->priv;
1769
1770 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1771
1772 /* Shift to get page */
1773 page = (int) (to >> this->page_shift);
1774 chipnr = (int) (to >> this->chip_shift);
1775
1776 /* Mask to get column */
1777 column = to & (mtd->oobsize - 1);
1778
1779 /* Initialize return length value */
1780 *retlen = 0;
1781
1782 /* Do not allow write past end of page */
1783 if ((column + len) > mtd->oobsize) {
1784 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1785 return -EINVAL;
1786 }
1787
1788 /* Grab the lock and see if the device is available */
1789 nand_get_device (this, mtd, FL_WRITING);
1790
1791 /* Select the NAND device */
1792 this->select_chip(mtd, chipnr);
1793
1794 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1795 in one of my DiskOnChip 2000 test units) will clear the whole
1796 data page too if we don't do this. I have no clue why, but
1797 I seem to have 'fixed' it in the doc2000 driver in
1798 August 1999. dwmw2. */
1799 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1800
1801 /* Check, if it is write protected */
1802 if (nand_check_wp(mtd))
1803 goto out;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001804
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001805 /* Invalidate the page cache, if we write to the cached page */
1806 if (page == this->pagebuf)
1807 this->pagebuf = -1;
1808
1809 if (NAND_MUST_PAD(this)) {
1810 /* Write out desired data */
1811 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1812 /* prepad 0xff for partial programming */
1813 this->write_buf(mtd, ffchars, column);
1814 /* write data */
1815 this->write_buf(mtd, buf, len);
1816 /* postpad 0xff for partial programming */
1817 this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));
1818 } else {
1819 /* Write out desired data */
1820 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1821 /* write data */
1822 this->write_buf(mtd, buf, len);
1823 }
1824 /* Send command to program the OOB data */
1825 this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);
1826
1827 status = this->waitfunc (mtd, this, FL_WRITING);
1828
1829 /* See if device thinks it succeeded */
1830 if (status & 0x01) {
1831 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1832 ret = -EIO;
1833 goto out;
1834 }
1835 /* Return happy */
1836 *retlen = len;
1837
1838#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1839 /* Send command to read back the data */
1840 this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1841
1842 if (this->verify_buf(mtd, buf, len)) {
1843 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1844 ret = -EIO;
1845 goto out;
1846 }
1847#endif
1848 ret = 0;
1849out:
1850 /* Deselect and wake up anyone waiting on the device */
1851 nand_release_device(mtd);
1852
1853 return ret;
1854}
1855
1856/* XXX U-BOOT XXX */
1857#if 0
1858/**
1859 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1860 * @mtd: MTD device structure
1861 * @vecs: the iovectors to write
1862 * @count: number of vectors
1863 * @to: offset to write to
1864 * @retlen: pointer to variable to store the number of written bytes
1865 *
1866 * NAND write with kvec. This just calls the ecc function
1867 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001868static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001869 loff_t to, size_t * retlen)
1870{
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001871 return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001872}
1873
1874/**
1875 * nand_writev_ecc - [MTD Interface] write with iovec with ecc
1876 * @mtd: MTD device structure
1877 * @vecs: the iovectors to write
1878 * @count: number of vectors
1879 * @to: offset to write to
1880 * @retlen: pointer to variable to store the number of written bytes
1881 * @eccbuf: filesystem supplied oob data buffer
1882 * @oobsel: oob selection structure
1883 *
1884 * NAND write with iovec with ecc
1885 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001886static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001887 loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
1888{
1889 int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1890 int oob, numpages, autoplace = 0, startpage;
1891 struct nand_chip *this = mtd->priv;
1892 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1893 u_char *oobbuf, *bufstart;
1894
1895 /* Preset written len for early exit */
1896 *retlen = 0;
1897
1898 /* Calculate total length of data */
1899 total_len = 0;
1900 for (i = 0; i < count; i++)
1901 total_len += (int) vecs[i].iov_len;
1902
1903 DEBUG (MTD_DEBUG_LEVEL3,
1904 "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
1905
1906 /* Do not allow write past end of page */
1907 if ((to + total_len) > mtd->size) {
1908 DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1909 return -EINVAL;
1910 }
1911
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001912 /* reject writes, which are not page aligned */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001913 if (NOTALIGNED (to) || NOTALIGNED(total_len)) {
1914 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1915 return -EINVAL;
1916 }
1917
1918 /* Grab the lock and see if the device is available */
1919 nand_get_device (this, mtd, FL_WRITING);
1920
1921 /* Get the current chip-nr */
1922 chipnr = (int) (to >> this->chip_shift);
1923 /* Select the NAND device */
1924 this->select_chip(mtd, chipnr);
1925
1926 /* Check, if it is write protected */
1927 if (nand_check_wp(mtd))
1928 goto out;
1929
1930 /* if oobsel is NULL, use chip defaults */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001931 if (oobsel == NULL)
1932 oobsel = &mtd->oobinfo;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001933
1934 /* Autoplace of oob data ? Use the default placement scheme */
1935 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1936 oobsel = this->autooob;
1937 autoplace = 1;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001938 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001939 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1940 autoplace = 1;
1941
1942 /* Setup start page */
1943 page = (int) (to >> this->page_shift);
1944 /* Invalidate the page cache, if we write to the cached page */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001945 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001946 this->pagebuf = -1;
1947
1948 startpage = page & this->pagemask;
1949
1950 /* Loop until all kvec' data has been written */
1951 len = 0;
1952 while (count) {
1953 /* If the given tuple is >= pagesize then
1954 * write it out from the iov
1955 */
1956 if ((vecs->iov_len - len) >= mtd->oobblock) {
1957 /* Calc number of pages we can write
1958 * out of this iov in one go */
1959 numpages = (vecs->iov_len - len) >> this->page_shift;
1960 /* Do not cross block boundaries */
1961 numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);
1962 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1963 bufstart = (u_char *)vecs->iov_base;
1964 bufstart += len;
1965 this->data_poi = bufstart;
1966 oob = 0;
1967 for (i = 1; i <= numpages; i++) {
1968 /* Write one page. If this is the last page to write
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001969 * then use the real pageprogram command, else select
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001970 * cached programming if supported by the chip.
1971 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001972 ret = nand_write_page (mtd, this, page & this->pagemask,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001973 &oobbuf[oob], oobsel, i != numpages);
1974 if (ret)
1975 goto out;
1976 this->data_poi += mtd->oobblock;
1977 len += mtd->oobblock;
1978 oob += mtd->oobsize;
1979 page++;
1980 }
1981 /* Check, if we have to switch to the next tuple */
1982 if (len >= (int) vecs->iov_len) {
1983 vecs++;
1984 len = 0;
1985 count--;
1986 }
1987 } else {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001988 /* We must use the internal buffer, read data out of each
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001989 * tuple until we have a full page to write
1990 */
1991 int cnt = 0;
1992 while (cnt < mtd->oobblock) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02001993 if (vecs->iov_base != NULL && vecs->iov_len)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02001994 this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
1995 /* Check, if we have to switch to the next tuple */
1996 if (len >= (int) vecs->iov_len) {
1997 vecs++;
1998 len = 0;
1999 count--;
2000 }
2001 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002002 this->pagebuf = page;
2003 this->data_poi = this->data_buf;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002004 bufstart = this->data_poi;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002005 numpages = 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002006 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
2007 ret = nand_write_page (mtd, this, page & this->pagemask,
2008 oobbuf, oobsel, 0);
2009 if (ret)
2010 goto out;
2011 page++;
2012 }
2013
2014 this->data_poi = bufstart;
2015 ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
2016 if (ret)
2017 goto out;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002018
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002019 written += mtd->oobblock * numpages;
2020 /* All done ? */
2021 if (!count)
2022 break;
2023
2024 startpage = page & this->pagemask;
2025 /* Check, if we cross a chip boundary */
2026 if (!startpage) {
2027 chipnr++;
2028 this->select_chip(mtd, -1);
2029 this->select_chip(mtd, chipnr);
2030 }
2031 }
2032 ret = 0;
2033out:
2034 /* Deselect and wake up anyone waiting on the device */
2035 nand_release_device(mtd);
2036
2037 *retlen = written;
2038 return ret;
2039}
2040#endif
2041
2042/**
2043 * single_erease_cmd - [GENERIC] NAND standard block erase command function
2044 * @mtd: MTD device structure
2045 * @page: the page address of the block which will be erased
2046 *
2047 * Standard erase command for NAND chips
2048 */
2049static void single_erase_cmd (struct mtd_info *mtd, int page)
2050{
2051 struct nand_chip *this = mtd->priv;
2052 /* Send commands to erase a block */
2053 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2054 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2055}
2056
2057/**
2058 * multi_erease_cmd - [GENERIC] AND specific block erase command function
2059 * @mtd: MTD device structure
2060 * @page: the page address of the block which will be erased
2061 *
2062 * AND multi block erase command function
2063 * Erase 4 consecutive blocks
2064 */
2065static void multi_erase_cmd (struct mtd_info *mtd, int page)
2066{
2067 struct nand_chip *this = mtd->priv;
2068 /* Send commands to erase a block */
2069 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2070 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2071 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2072 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2073 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2074}
2075
2076/**
2077 * nand_erase - [MTD Interface] erase block(s)
2078 * @mtd: MTD device structure
2079 * @instr: erase instruction
2080 *
2081 * Erase one ore more blocks
2082 */
2083static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
2084{
2085 return nand_erase_nand (mtd, instr, 0);
2086}
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002087
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002088/**
2089 * nand_erase_intern - [NAND Interface] erase block(s)
2090 * @mtd: MTD device structure
2091 * @instr: erase instruction
2092 * @allowbbt: allow erasing the bbt area
2093 *
2094 * Erase one ore more blocks
2095 */
2096int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2097{
2098 int page, len, status, pages_per_block, ret, chipnr;
2099 struct nand_chip *this = mtd->priv;
2100
2101 DEBUG (MTD_DEBUG_LEVEL3,
2102 "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
2103
2104 /* Start address must align on block boundary */
2105 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2106 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2107 return -EINVAL;
2108 }
2109
2110 /* Length must align on block boundary */
2111 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2112 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2113 return -EINVAL;
2114 }
2115
2116 /* Do not allow erase past end of device */
2117 if ((instr->len + instr->addr) > mtd->size) {
2118 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2119 return -EINVAL;
2120 }
2121
2122 instr->fail_addr = 0xffffffff;
2123
2124 /* Grab the lock and see if the device is available */
2125 nand_get_device (this, mtd, FL_ERASING);
2126
2127 /* Shift to get first page */
2128 page = (int) (instr->addr >> this->page_shift);
2129 chipnr = (int) (instr->addr >> this->chip_shift);
2130
2131 /* Calculate pages in each block */
2132 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
2133
2134 /* Select the NAND device */
2135 this->select_chip(mtd, chipnr);
2136
2137 /* Check the WP bit */
2138 /* Check, if it is write protected */
2139 if (nand_check_wp(mtd)) {
2140 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2141 instr->state = MTD_ERASE_FAILED;
2142 goto erase_exit;
2143 }
2144
2145 /* Loop through the pages */
2146 len = instr->len;
2147
2148 instr->state = MTD_ERASING;
2149
2150 while (len) {
Markus Klotzbücher85678e22006-03-06 13:45:42 +01002151#ifndef NAND_ALLOW_ERASE_ALL
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002152 /* Check if we have a bad block, we do not erase bad blocks ! */
2153 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2154 printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2155 instr->state = MTD_ERASE_FAILED;
2156 goto erase_exit;
2157 }
Markus Klotzbücher85678e22006-03-06 13:45:42 +01002158#endif
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002159 /* Invalidate the page cache, if we erase the block which contains
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002160 the current cached page */
2161 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2162 this->pagebuf = -1;
2163
2164 this->erase_cmd (mtd, page & this->pagemask);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002165
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002166 status = this->waitfunc (mtd, this, FL_ERASING);
2167
2168 /* See if block erase succeeded */
2169 if (status & 0x01) {
2170 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2171 instr->state = MTD_ERASE_FAILED;
2172 instr->fail_addr = (page << this->page_shift);
2173 goto erase_exit;
2174 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002175
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002176 /* Increment page address and decrement length */
2177 len -= (1 << this->phys_erase_shift);
2178 page += pages_per_block;
2179
2180 /* Check, if we cross a chip boundary */
2181 if (len && !(page & this->pagemask)) {
2182 chipnr++;
2183 this->select_chip(mtd, -1);
2184 this->select_chip(mtd, chipnr);
2185 }
2186 }
2187 instr->state = MTD_ERASE_DONE;
2188
2189erase_exit:
2190
2191 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2192 /* Do call back function */
2193 if (!ret)
2194 mtd_erase_callback(instr);
2195
2196 /* Deselect and wake up anyone waiting on the device */
2197 nand_release_device(mtd);
2198
2199 /* Return more or less happy */
2200 return ret;
2201}
2202
2203/**
2204 * nand_sync - [MTD Interface] sync
2205 * @mtd: MTD device structure
2206 *
2207 * Sync is actually a wait for chip ready function
2208 */
2209static void nand_sync (struct mtd_info *mtd)
2210{
2211 struct nand_chip *this = mtd->priv;
2212
2213 DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2214
2215 /* Grab the lock and see if the device is available */
2216 nand_get_device (this, mtd, FL_SYNCING);
2217 /* Release it and go back */
2218 nand_release_device (mtd);
2219}
2220
2221
2222/**
2223 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2224 * @mtd: MTD device structure
2225 * @ofs: offset relative to mtd start
2226 */
2227static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
2228{
2229 /* Check for invalid offset */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002230 if (ofs > mtd->size)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002231 return -EINVAL;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002232
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002233 return nand_block_checkbad (mtd, ofs, 1, 0);
2234}
2235
2236/**
2237 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2238 * @mtd: MTD device structure
2239 * @ofs: offset relative to mtd start
2240 */
2241static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
2242{
2243 struct nand_chip *this = mtd->priv;
2244 int ret;
2245
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002246 if ((ret = nand_block_isbad(mtd, ofs))) {
2247 /* If it was bad already, return success and do nothing. */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002248 if (ret > 0)
2249 return 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002250 return ret;
2251 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002252
2253 return this->block_markbad(mtd, ofs);
2254}
2255
2256/**
2257 * nand_scan - [NAND Interface] Scan for the NAND device
2258 * @mtd: MTD device structure
2259 * @maxchips: Number of chips to scan for
2260 *
2261 * This fills out all the not initialized function pointers
2262 * with the defaults.
2263 * The flash ID is read and the mtd/chip structures are
2264 * filled with the appropriate values. Buffers are allocated if
2265 * they are not provided by the board driver
2266 *
2267 */
2268int nand_scan (struct mtd_info *mtd, int maxchips)
2269{
2270 int i, j, nand_maf_id, nand_dev_id, busw;
2271 struct nand_chip *this = mtd->priv;
2272
2273 /* Get buswidth to select the correct functions*/
2274 busw = this->options & NAND_BUSWIDTH_16;
2275
2276 /* check for proper chip_delay setup, set 20us if not */
2277 if (!this->chip_delay)
2278 this->chip_delay = 20;
2279
2280 /* check, if a user supplied command function given */
2281 if (this->cmdfunc == NULL)
2282 this->cmdfunc = nand_command;
2283
2284 /* check, if a user supplied wait function given */
2285 if (this->waitfunc == NULL)
2286 this->waitfunc = nand_wait;
2287
2288 if (!this->select_chip)
2289 this->select_chip = nand_select_chip;
2290 if (!this->write_byte)
2291 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2292 if (!this->read_byte)
2293 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2294 if (!this->write_word)
2295 this->write_word = nand_write_word;
2296 if (!this->read_word)
2297 this->read_word = nand_read_word;
2298 if (!this->block_bad)
2299 this->block_bad = nand_block_bad;
2300 if (!this->block_markbad)
2301 this->block_markbad = nand_default_block_markbad;
2302 if (!this->write_buf)
2303 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2304 if (!this->read_buf)
2305 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2306 if (!this->verify_buf)
2307 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2308 if (!this->scan_bbt)
2309 this->scan_bbt = nand_default_bbt;
2310
2311 /* Select the device */
2312 this->select_chip(mtd, 0);
2313
2314 /* Send the command for reading device ID */
2315 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2316
2317 /* Read manufacturer and device IDs */
2318 nand_maf_id = this->read_byte(mtd);
2319 nand_dev_id = this->read_byte(mtd);
2320
2321 /* Print and store flash device information */
2322 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002323
2324 if (nand_dev_id != nand_flash_ids[i].id)
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002325 continue;
2326
2327 if (!mtd->name) mtd->name = nand_flash_ids[i].name;
2328 this->chipsize = nand_flash_ids[i].chipsize << 20;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002329
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002330 /* New devices have all the information in additional id bytes */
2331 if (!nand_flash_ids[i].pagesize) {
2332 int extid;
2333 /* The 3rd id byte contains non relevant data ATM */
2334 extid = this->read_byte(mtd);
2335 /* The 4th id byte is the important one */
2336 extid = this->read_byte(mtd);
2337 /* Calc pagesize */
2338 mtd->oobblock = 1024 << (extid & 0x3);
2339 extid >>= 2;
2340 /* Calc oobsize */
Stefan Roesee58a4af2007-01-05 11:46:05 +01002341 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->oobblock / 512);
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002342 extid >>= 2;
2343 /* Calc blocksize. Blocksize is multiples of 64KiB */
2344 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2345 extid >>= 2;
2346 /* Get buswidth information */
2347 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002348
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002349 } else {
2350 /* Old devices have this data hardcoded in the
2351 * device id table */
2352 mtd->erasesize = nand_flash_ids[i].erasesize;
2353 mtd->oobblock = nand_flash_ids[i].pagesize;
2354 mtd->oobsize = mtd->oobblock / 32;
2355 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2356 }
2357
2358 /* Check, if buswidth is correct. Hardware drivers should set
2359 * this correct ! */
2360 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2361 printk (KERN_INFO "NAND device: Manufacturer ID:"
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002362 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002363 nand_manuf_ids[i].name , mtd->name);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002364 printk (KERN_WARNING
2365 "NAND bus width %d instead %d bit\n",
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002366 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2367 busw ? 16 : 8);
2368 this->select_chip(mtd, -1);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002369 return 1;
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002370 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002371
2372 /* Calculate the address shift from the page size */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002373 this->page_shift = ffs(mtd->oobblock) - 1;
2374 this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
2375 this->chip_shift = ffs(this->chipsize) - 1;
2376
2377 /* Set the bad block position */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002378 this->badblockpos = mtd->oobblock > 512 ?
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002379 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2380
2381 /* Get chip options, preserve non chip based options */
2382 this->options &= ~NAND_CHIPOPTIONS_MSK;
2383 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2384 /* Set this as a default. Board drivers can override it, if neccecary */
2385 this->options |= NAND_NO_AUTOINCR;
2386 /* Check if this is a not a samsung device. Do not clear the options
2387 * for chips which are not having an extended id.
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002388 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002389 if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2390 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002391
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002392 /* Check for AND chips with 4 page planes */
2393 if (this->options & NAND_4PAGE_ARRAY)
2394 this->erase_cmd = multi_erase_cmd;
2395 else
2396 this->erase_cmd = single_erase_cmd;
2397
2398 /* Do not replace user supplied command function ! */
2399 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2400 this->cmdfunc = nand_command_lp;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002401
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002402 /* Try to identify manufacturer */
2403 for (j = 0; nand_manuf_ids[j].id != 0x0; j++) {
2404 if (nand_manuf_ids[j].id == nand_maf_id)
2405 break;
2406 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002407 break;
2408 }
2409
2410 if (!nand_flash_ids[i].name) {
Stefan Roese47cf6a52006-10-07 11:36:51 +02002411#ifndef CFG_NAND_QUIET_TEST
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002412 printk (KERN_WARNING "No NAND device found!!!\n");
Stefan Roese47cf6a52006-10-07 11:36:51 +02002413#endif
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002414 this->select_chip(mtd, -1);
2415 return 1;
2416 }
2417
2418 for (i=1; i < maxchips; i++) {
2419 this->select_chip(mtd, i);
2420
2421 /* Send the command for reading device ID */
2422 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2423
2424 /* Read manufacturer and device IDs */
2425 if (nand_maf_id != this->read_byte(mtd) ||
2426 nand_dev_id != this->read_byte(mtd))
2427 break;
2428 }
2429 if (i > 1)
2430 printk(KERN_INFO "%d NAND chips detected\n", i);
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002431
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002432 /* Allocate buffers, if neccecary */
2433 if (!this->oob_buf) {
2434 size_t len;
2435 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
2436 this->oob_buf = kmalloc (len, GFP_KERNEL);
2437 if (!this->oob_buf) {
2438 printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
2439 return -ENOMEM;
2440 }
2441 this->options |= NAND_OOBBUF_ALLOC;
2442 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002443
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002444 if (!this->data_buf) {
2445 size_t len;
2446 len = mtd->oobblock + mtd->oobsize;
2447 this->data_buf = kmalloc (len, GFP_KERNEL);
2448 if (!this->data_buf) {
2449 if (this->options & NAND_OOBBUF_ALLOC)
2450 kfree (this->oob_buf);
2451 printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
2452 return -ENOMEM;
2453 }
2454 this->options |= NAND_DATABUF_ALLOC;
2455 }
2456
2457 /* Store the number of chips and calc total size for mtd */
2458 this->numchips = i;
2459 mtd->size = i * this->chipsize;
2460 /* Convert chipsize to number of pages per chip -1. */
2461 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2462 /* Preset the internal oob buffer */
2463 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2464
2465 /* If no default placement scheme is given, select an
2466 * appropriate one */
2467 if (!this->autooob) {
2468 /* Select the appropriate default oob placement scheme for
2469 * placement agnostic filesystems */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002470 switch (mtd->oobsize) {
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002471 case 8:
2472 this->autooob = &nand_oob_8;
2473 break;
2474 case 16:
2475 this->autooob = &nand_oob_16;
2476 break;
2477 case 64:
2478 this->autooob = &nand_oob_64;
2479 break;
2480 default:
2481 printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
2482 mtd->oobsize);
2483/* BUG(); */
2484 }
2485 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002486
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002487 /* The number of bytes available for the filesystem to place fs dependend
2488 * oob data */
2489 if (this->options & NAND_BUSWIDTH_16) {
2490 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 2);
2491 if (this->autooob->eccbytes & 0x01)
2492 mtd->oobavail--;
2493 } else
2494 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 1);
2495
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002496 /*
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002497 * check ECC mode, default to software
2498 * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002499 * fallback to software ECC
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002500 */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002501 this->eccsize = 256; /* set default eccsize */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002502 this->eccbytes = 3;
2503
2504 switch (this->eccmode) {
2505 case NAND_ECC_HW12_2048:
2506 if (mtd->oobblock < 2048) {
2507 printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
2508 mtd->oobblock);
2509 this->eccmode = NAND_ECC_SOFT;
2510 this->calculate_ecc = nand_calculate_ecc;
2511 this->correct_data = nand_correct_data;
2512 } else
2513 this->eccsize = 2048;
2514 break;
2515
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002516 case NAND_ECC_HW3_512:
2517 case NAND_ECC_HW6_512:
2518 case NAND_ECC_HW8_512:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002519 if (mtd->oobblock == 256) {
2520 printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
2521 this->eccmode = NAND_ECC_SOFT;
2522 this->calculate_ecc = nand_calculate_ecc;
2523 this->correct_data = nand_correct_data;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002524 } else
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002525 this->eccsize = 512; /* set eccsize to 512 */
2526 break;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002527
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002528 case NAND_ECC_HW3_256:
2529 break;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002530
2531 case NAND_ECC_NONE:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002532 printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
2533 this->eccmode = NAND_ECC_NONE;
2534 break;
2535
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002536 case NAND_ECC_SOFT:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002537 this->calculate_ecc = nand_calculate_ecc;
2538 this->correct_data = nand_correct_data;
2539 break;
2540
2541 default:
2542 printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
2543/* BUG(); */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002544 }
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002545
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002546 /* Check hardware ecc function availability and adjust number of ecc bytes per
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002547 * calculation step
2548 */
2549 switch (this->eccmode) {
2550 case NAND_ECC_HW12_2048:
2551 this->eccbytes += 4;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002552 case NAND_ECC_HW8_512:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002553 this->eccbytes += 2;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002554 case NAND_ECC_HW6_512:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002555 this->eccbytes += 3;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002556 case NAND_ECC_HW3_512:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002557 case NAND_ECC_HW3_256:
2558 if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
2559 break;
2560 printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
2561/* BUG(); */
2562 }
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002563
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002564 mtd->eccsize = this->eccsize;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002565
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002566 /* Set the number of read / write steps for one page to ensure ECC generation */
2567 switch (this->eccmode) {
2568 case NAND_ECC_HW12_2048:
2569 this->eccsteps = mtd->oobblock / 2048;
2570 break;
2571 case NAND_ECC_HW3_512:
2572 case NAND_ECC_HW6_512:
2573 case NAND_ECC_HW8_512:
2574 this->eccsteps = mtd->oobblock / 512;
2575 break;
2576 case NAND_ECC_HW3_256:
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002577 case NAND_ECC_SOFT:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002578 this->eccsteps = mtd->oobblock / 256;
2579 break;
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002580
2581 case NAND_ECC_NONE:
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002582 this->eccsteps = 1;
2583 break;
2584 }
2585
2586/* XXX U-BOOT XXX */
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002587#if 0
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002588 /* Initialize state, waitqueue and spinlock */
2589 this->state = FL_READY;
2590 init_waitqueue_head (&this->wq);
2591 spin_lock_init (&this->chip_lock);
2592#endif
2593
2594 /* De-select the device */
2595 this->select_chip(mtd, -1);
2596
2597 /* Invalidate the pagebuffer reference */
2598 this->pagebuf = -1;
2599
2600 /* Fill in remaining MTD driver data */
2601 mtd->type = MTD_NANDFLASH;
2602 mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
2603 mtd->ecctype = MTD_ECC_SW;
2604 mtd->erase = nand_erase;
2605 mtd->point = NULL;
2606 mtd->unpoint = NULL;
2607 mtd->read = nand_read;
2608 mtd->write = nand_write;
2609 mtd->read_ecc = nand_read_ecc;
2610 mtd->write_ecc = nand_write_ecc;
2611 mtd->read_oob = nand_read_oob;
2612 mtd->write_oob = nand_write_oob;
2613/* XXX U-BOOT XXX */
2614#if 0
2615 mtd->readv = NULL;
2616 mtd->writev = nand_writev;
2617 mtd->writev_ecc = nand_writev_ecc;
2618#endif
2619 mtd->sync = nand_sync;
2620/* XXX U-BOOT XXX */
2621#if 0
2622 mtd->lock = NULL;
2623 mtd->unlock = NULL;
2624 mtd->suspend = NULL;
2625 mtd->resume = NULL;
2626#endif
2627 mtd->block_isbad = nand_block_isbad;
2628 mtd->block_markbad = nand_block_markbad;
2629
2630 /* and make the autooob the default one */
2631 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2632/* XXX U-BOOT XXX */
2633#if 0
2634 mtd->owner = THIS_MODULE;
2635#endif
2636 /* Build bad block table */
2637 return this->scan_bbt (mtd);
2638}
2639
2640/**
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002641 * nand_release - [NAND Interface] Free resources held by the NAND device
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002642 * @mtd: MTD device structure
Wolfgang Denk7b9bc3a2005-09-14 23:53:32 +02002643 */
Wolfgang Denk2f9b7e42005-08-17 12:55:25 +02002644void nand_release (struct mtd_info *mtd)
2645{
2646 struct nand_chip *this = mtd->priv;
2647
2648#ifdef CONFIG_MTD_PARTITIONS
2649 /* Deregister partitions */
2650 del_mtd_partitions (mtd);
2651#endif
2652 /* Deregister the device */
2653/* XXX U-BOOT XXX */
2654#if 0
2655 del_mtd_device (mtd);
2656#endif
2657 /* Free bad block table memory, if allocated */
2658 if (this->bbt)
2659 kfree (this->bbt);
2660 /* Buffer allocated by nand_scan ? */
2661 if (this->options & NAND_OOBBUF_ALLOC)
2662 kfree (this->oob_buf);
2663 /* Buffer allocated by nand_scan ? */
2664 if (this->options & NAND_DATABUF_ALLOC)
2665 kfree (this->data_buf);
2666}
2667
2668#endif