blob: a7ab8c27adcb93c9d40346d6c64fea0a7c04cd34 [file] [log] [blame]
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +02008 *
Wolfgang Denk932394a2005-08-17 12:55:25 +02009 * Additional technical information is available on
10 * http://www.linux-mtd.infradead.org/tech/nand.html
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +020011 *
Wolfgang Denk932394a2005-08-17 12:55:25 +020012 * Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
13 * 2002 Thomas Gleixner (tglx@linutronix.de)
14 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +020015 * 02-08-2004 tglx: support for strange chips, which cannot auto increment
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +020024 *
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +020032 * David Woodhouse for adding multichip support
33 *
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +020071#endif
Wolfgang Denk932394a2005-08-17 12:55:25 +020072
73#include <common.h>
74
75#if (CONFIG_COMMANDS & CFG_CMD_NAND)
76
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 Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +0200110 40, 41, 42, 43, 44, 45, 46, 47,
111 48, 49, 50, 51, 52, 53, 54, 55,
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +0200157static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +0200162
Wolfgang Denk932394a2005-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 Denkac7eb8a32005-09-14 23:53:32 +0200168 *
169 * Deselect, release chip lock and wake up anyone waiting on the device
Wolfgang Denk932394a2005-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
192#define nand_release_device(mtd) do {} while(0)
193#endif
194
195/**
196 * nand_read_byte - [DEFAULT] read one byte from the chip
197 * @mtd: MTD device structure
198 *
199 * Default read function for 8bit buswith
200 */
201static u_char nand_read_byte(struct mtd_info *mtd)
202{
203 struct nand_chip *this = mtd->priv;
204 return readb(this->IO_ADDR_R);
205}
206
207/**
208 * nand_write_byte - [DEFAULT] write one byte to the chip
209 * @mtd: MTD device structure
210 * @byte: pointer to data byte to write
211 *
212 * Default write function for 8it buswith
213 */
214static void nand_write_byte(struct mtd_info *mtd, u_char byte)
215{
216 struct nand_chip *this = mtd->priv;
217 writeb(byte, this->IO_ADDR_W);
218}
219
220/**
221 * nand_read_byte16 - [DEFAULT] read one byte endianess aware from the chip
222 * @mtd: MTD device structure
223 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200224 * Default read function for 16bit buswith with
Wolfgang Denk932394a2005-08-17 12:55:25 +0200225 * endianess conversion
226 */
227static u_char nand_read_byte16(struct mtd_info *mtd)
228{
229 struct nand_chip *this = mtd->priv;
230 return (u_char) cpu_to_le16(readw(this->IO_ADDR_R));
231}
232
233/**
234 * nand_write_byte16 - [DEFAULT] write one byte endianess aware to the chip
235 * @mtd: MTD device structure
236 * @byte: pointer to data byte to write
237 *
238 * Default write function for 16bit buswith with
239 * endianess conversion
240 */
241static void nand_write_byte16(struct mtd_info *mtd, u_char byte)
242{
243 struct nand_chip *this = mtd->priv;
244 writew(le16_to_cpu((u16) byte), this->IO_ADDR_W);
245}
246
247/**
248 * nand_read_word - [DEFAULT] read one word from the chip
249 * @mtd: MTD device structure
250 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200251 * Default read function for 16bit buswith without
Wolfgang Denk932394a2005-08-17 12:55:25 +0200252 * endianess conversion
253 */
254static u16 nand_read_word(struct mtd_info *mtd)
255{
256 struct nand_chip *this = mtd->priv;
257 return readw(this->IO_ADDR_R);
258}
259
260/**
261 * nand_write_word - [DEFAULT] write one word to the chip
262 * @mtd: MTD device structure
263 * @word: data word to write
264 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200265 * Default write function for 16bit buswith without
Wolfgang Denk932394a2005-08-17 12:55:25 +0200266 * endianess conversion
267 */
268static void nand_write_word(struct mtd_info *mtd, u16 word)
269{
270 struct nand_chip *this = mtd->priv;
271 writew(word, this->IO_ADDR_W);
272}
273
274/**
275 * nand_select_chip - [DEFAULT] control CE line
276 * @mtd: MTD device structure
277 * @chip: chipnumber to select, -1 for deselect
278 *
279 * Default select function for 1 chip devices.
280 */
281static void nand_select_chip(struct mtd_info *mtd, int chip)
282{
283 struct nand_chip *this = mtd->priv;
284 switch(chip) {
285 case -1:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200286 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
Wolfgang Denk932394a2005-08-17 12:55:25 +0200287 break;
288 case 0:
289 this->hwcontrol(mtd, NAND_CTL_SETNCE);
290 break;
291
292 default:
293 BUG();
294 }
295}
296
297/**
298 * nand_write_buf - [DEFAULT] write buffer to chip
299 * @mtd: MTD device structure
300 * @buf: data buffer
301 * @len: number of bytes to write
302 *
303 * Default write function for 8bit buswith
304 */
305static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
306{
307 int i;
308 struct nand_chip *this = mtd->priv;
309
310 for (i=0; i<len; i++)
311 writeb(buf[i], this->IO_ADDR_W);
312}
313
314/**
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200315 * nand_read_buf - [DEFAULT] read chip data into buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +0200316 * @mtd: MTD device structure
317 * @buf: buffer to store date
318 * @len: number of bytes to read
319 *
320 * Default read function for 8bit buswith
321 */
322static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
323{
324 int i;
325 struct nand_chip *this = mtd->priv;
326
327 for (i=0; i<len; i++)
328 buf[i] = readb(this->IO_ADDR_R);
329}
330
331/**
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200332 * nand_verify_buf - [DEFAULT] Verify chip data against buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +0200333 * @mtd: MTD device structure
334 * @buf: buffer containing the data to compare
335 * @len: number of bytes to compare
336 *
337 * Default verify function for 8bit buswith
338 */
339static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
340{
341 int i;
342 struct nand_chip *this = mtd->priv;
343
344 for (i=0; i<len; i++)
345 if (buf[i] != readb(this->IO_ADDR_R))
346 return -EFAULT;
347
348 return 0;
349}
350
351/**
352 * nand_write_buf16 - [DEFAULT] write buffer to chip
353 * @mtd: MTD device structure
354 * @buf: data buffer
355 * @len: number of bytes to write
356 *
357 * Default write function for 16bit buswith
358 */
359static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
360{
361 int i;
362 struct nand_chip *this = mtd->priv;
363 u16 *p = (u16 *) buf;
364 len >>= 1;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200365
Wolfgang Denk932394a2005-08-17 12:55:25 +0200366 for (i=0; i<len; i++)
367 writew(p[i], this->IO_ADDR_W);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200368
Wolfgang Denk932394a2005-08-17 12:55:25 +0200369}
370
371/**
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200372 * nand_read_buf16 - [DEFAULT] read chip data into buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +0200373 * @mtd: MTD device structure
374 * @buf: buffer to store date
375 * @len: number of bytes to read
376 *
377 * Default read function for 16bit buswith
378 */
379static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
380{
381 int i;
382 struct nand_chip *this = mtd->priv;
383 u16 *p = (u16 *) buf;
384 len >>= 1;
385
386 for (i=0; i<len; i++)
387 p[i] = readw(this->IO_ADDR_R);
388}
389
390/**
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200391 * nand_verify_buf16 - [DEFAULT] Verify chip data against buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +0200392 * @mtd: MTD device structure
393 * @buf: buffer containing the data to compare
394 * @len: number of bytes to compare
395 *
396 * Default verify function for 16bit buswith
397 */
398static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
399{
400 int i;
401 struct nand_chip *this = mtd->priv;
402 u16 *p = (u16 *) buf;
403 len >>= 1;
404
405 for (i=0; i<len; i++)
406 if (p[i] != readw(this->IO_ADDR_R))
407 return -EFAULT;
408
409 return 0;
410}
411
412/**
413 * nand_block_bad - [DEFAULT] Read bad block marker from the chip
414 * @mtd: MTD device structure
415 * @ofs: offset from device start
416 * @getchip: 0, if the chip is already selected
417 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200418 * Check, if the block is bad.
Wolfgang Denk932394a2005-08-17 12:55:25 +0200419 */
420static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
421{
422 int page, chipnr, res = 0;
423 struct nand_chip *this = mtd->priv;
424 u16 bad;
425
426 if (getchip) {
427 page = (int)(ofs >> this->page_shift);
428 chipnr = (int)(ofs >> this->chip_shift);
429
430 /* Grab the lock and see if the device is available */
431 nand_get_device (this, mtd, FL_READING);
432
433 /* Select the NAND device */
434 this->select_chip(mtd, chipnr);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200435 } else
436 page = (int) ofs;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200437
438 if (this->options & NAND_BUSWIDTH_16) {
439 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
440 bad = cpu_to_le16(this->read_word(mtd));
441 if (this->badblockpos & 0x1)
442 bad >>= 1;
443 if ((bad & 0xFF) != 0xff)
444 res = 1;
445 } else {
446 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
447 if (this->read_byte(mtd) != 0xff)
448 res = 1;
449 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200450
Wolfgang Denk932394a2005-08-17 12:55:25 +0200451 if (getchip) {
452 /* Deselect and wake up anyone waiting on the device */
453 nand_release_device(mtd);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200454 }
455
Wolfgang Denk932394a2005-08-17 12:55:25 +0200456 return res;
457}
458
459/**
460 * nand_default_block_markbad - [DEFAULT] mark a block bad
461 * @mtd: MTD device structure
462 * @ofs: offset from device start
463 *
464 * This is the default implementation, which can be overridden by
465 * a hardware specific driver.
466*/
467static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
468{
469 struct nand_chip *this = mtd->priv;
470 u_char buf[2] = {0, 0};
471 size_t retlen;
472 int block;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200473
Wolfgang Denk932394a2005-08-17 12:55:25 +0200474 /* Get block number */
475 block = ((int) ofs) >> this->bbt_erase_shift;
476 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
477
478 /* Do we have a flash based bad block table ? */
479 if (this->options & NAND_USE_FLASH_BBT)
480 return nand_update_bbt (mtd, ofs);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200481
Wolfgang Denk932394a2005-08-17 12:55:25 +0200482 /* We write two bytes, so we dont have to mess with 16 bit access */
483 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
484 return nand_write_oob (mtd, ofs , 2, &retlen, buf);
485}
486
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200487/**
Wolfgang Denk932394a2005-08-17 12:55:25 +0200488 * nand_check_wp - [GENERIC] check if the chip is write protected
489 * @mtd: MTD device structure
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200490 * Check, if the device is write protected
Wolfgang Denk932394a2005-08-17 12:55:25 +0200491 *
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200492 * The function expects, that the device is already selected
Wolfgang Denk932394a2005-08-17 12:55:25 +0200493 */
494static int nand_check_wp (struct mtd_info *mtd)
495{
496 struct nand_chip *this = mtd->priv;
497 /* Check the WP bit */
498 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200499 return (this->read_byte(mtd) & 0x80) ? 0 : 1;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200500}
501
502/**
503 * nand_block_checkbad - [GENERIC] Check if a block is marked bad
504 * @mtd: MTD device structure
505 * @ofs: offset from device start
506 * @getchip: 0, if the chip is already selected
507 * @allowbbt: 1, if its allowed to access the bbt area
508 *
509 * Check, if the block is bad. Either by reading the bad block table or
510 * calling of the scan function.
511 */
512static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
513{
514 struct nand_chip *this = mtd->priv;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200515
Wolfgang Denk932394a2005-08-17 12:55:25 +0200516 if (!this->bbt)
517 return this->block_bad(mtd, ofs, getchip);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200518
Wolfgang Denk932394a2005-08-17 12:55:25 +0200519 /* Return info from the table */
520 return nand_isbad_bbt (mtd, ofs, allowbbt);
521}
522
523/**
524 * nand_command - [DEFAULT] Send command to NAND device
525 * @mtd: MTD device structure
526 * @command: the command to be sent
527 * @column: the column address for this command, -1 if none
528 * @page_addr: the page address for this command, -1 if none
529 *
530 * Send command to NAND device. This function is used for small page
531 * devices (256/512 Bytes per page)
532 */
533static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
534{
535 register struct nand_chip *this = mtd->priv;
536
537 /* Begin command latch cycle */
538 this->hwcontrol(mtd, NAND_CTL_SETCLE);
539 /*
540 * Write out the command to the device.
541 */
542 if (command == NAND_CMD_SEQIN) {
543 int readcmd;
544
545 if (column >= mtd->oobblock) {
546 /* OOB area */
547 column -= mtd->oobblock;
548 readcmd = NAND_CMD_READOOB;
549 } else if (column < 256) {
550 /* First 256 bytes --> READ0 */
551 readcmd = NAND_CMD_READ0;
552 } else {
553 column -= 256;
554 readcmd = NAND_CMD_READ1;
555 }
556 this->write_byte(mtd, readcmd);
557 }
558 this->write_byte(mtd, command);
559
560 /* Set ALE and clear CLE to start address cycle */
561 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
562
563 if (column != -1 || page_addr != -1) {
564 this->hwcontrol(mtd, NAND_CTL_SETALE);
565
566 /* Serially input address */
567 if (column != -1) {
568 /* Adjust columns for 16 bit buswidth */
569 if (this->options & NAND_BUSWIDTH_16)
570 column >>= 1;
571 this->write_byte(mtd, column);
572 }
573 if (page_addr != -1) {
574 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
575 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
576 /* One more address cycle for devices > 32MiB */
577 if (this->chipsize > (32 << 20))
578 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f));
579 }
580 /* Latch in address */
581 this->hwcontrol(mtd, NAND_CTL_CLRALE);
582 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200583
584 /*
585 * program and erase have their own busy handlers
Wolfgang Denk932394a2005-08-17 12:55:25 +0200586 * status and sequential in needs no delay
587 */
588 switch (command) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200589
Wolfgang Denk932394a2005-08-17 12:55:25 +0200590 case NAND_CMD_PAGEPROG:
591 case NAND_CMD_ERASE1:
592 case NAND_CMD_ERASE2:
593 case NAND_CMD_SEQIN:
594 case NAND_CMD_STATUS:
595 return;
596
597 case NAND_CMD_RESET:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200598 if (this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +0200599 break;
600 udelay(this->chip_delay);
601 this->hwcontrol(mtd, NAND_CTL_SETCLE);
602 this->write_byte(mtd, NAND_CMD_STATUS);
603 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
604 while ( !(this->read_byte(mtd) & 0x40));
605 return;
606
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200607 /* This applies to read commands */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200608 default:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200609 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +0200610 * If we don't have access to the busy pin, we apply the given
611 * command delay
612 */
613 if (!this->dev_ready) {
614 udelay (this->chip_delay);
615 return;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200616 }
Wolfgang Denk932394a2005-08-17 12:55:25 +0200617 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200618
Wolfgang Denk932394a2005-08-17 12:55:25 +0200619 /* Apply this short delay always to ensure that we do wait tWB in
620 * any case on any machine. */
621 ndelay (100);
622 /* wait until command is processed */
623 while (!this->dev_ready(mtd));
624}
625
626/**
627 * nand_command_lp - [DEFAULT] Send command to NAND large page device
628 * @mtd: MTD device structure
629 * @command: the command to be sent
630 * @column: the column address for this command, -1 if none
631 * @page_addr: the page address for this command, -1 if none
632 *
633 * Send command to NAND device. This is the version for the new large page devices
634 * We dont have the seperate regions as we have in the small page devices.
635 * We must emulate NAND_CMD_READOOB to keep the code compatible.
636 *
637 */
638static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr)
639{
640 register struct nand_chip *this = mtd->priv;
641
642 /* Emulate NAND_CMD_READOOB */
643 if (command == NAND_CMD_READOOB) {
644 column += mtd->oobblock;
645 command = NAND_CMD_READ0;
646 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200647
648
Wolfgang Denk932394a2005-08-17 12:55:25 +0200649 /* Begin command latch cycle */
650 this->hwcontrol(mtd, NAND_CTL_SETCLE);
651 /* Write out the command to the device. */
652 this->write_byte(mtd, command);
653 /* End command latch cycle */
654 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
655
656 if (column != -1 || page_addr != -1) {
657 this->hwcontrol(mtd, NAND_CTL_SETALE);
658
659 /* Serially input address */
660 if (column != -1) {
661 /* Adjust columns for 16 bit buswidth */
662 if (this->options & NAND_BUSWIDTH_16)
663 column >>= 1;
664 this->write_byte(mtd, column & 0xff);
665 this->write_byte(mtd, column >> 8);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200666 }
Wolfgang Denk932394a2005-08-17 12:55:25 +0200667 if (page_addr != -1) {
668 this->write_byte(mtd, (unsigned char) (page_addr & 0xff));
669 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff));
670 /* One more address cycle for devices > 128MiB */
671 if (this->chipsize > (128 << 20))
672 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff));
673 }
674 /* Latch in address */
675 this->hwcontrol(mtd, NAND_CTL_CLRALE);
676 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200677
678 /*
679 * program and erase have their own busy handlers
Wolfgang Denk932394a2005-08-17 12:55:25 +0200680 * status and sequential in needs no delay
681 */
682 switch (command) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200683
Wolfgang Denk932394a2005-08-17 12:55:25 +0200684 case NAND_CMD_CACHEDPROG:
685 case NAND_CMD_PAGEPROG:
686 case NAND_CMD_ERASE1:
687 case NAND_CMD_ERASE2:
688 case NAND_CMD_SEQIN:
689 case NAND_CMD_STATUS:
690 return;
691
692
693 case NAND_CMD_RESET:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200694 if (this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +0200695 break;
696 udelay(this->chip_delay);
697 this->hwcontrol(mtd, NAND_CTL_SETCLE);
698 this->write_byte(mtd, NAND_CMD_STATUS);
699 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
700 while ( !(this->read_byte(mtd) & 0x40));
701 return;
702
703 case NAND_CMD_READ0:
704 /* Begin command latch cycle */
705 this->hwcontrol(mtd, NAND_CTL_SETCLE);
706 /* Write out the start read command */
707 this->write_byte(mtd, NAND_CMD_READSTART);
708 /* End command latch cycle */
709 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
710 /* Fall through into ready check */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200711
712 /* This applies to read commands */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200713 default:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200714 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +0200715 * If we don't have access to the busy pin, we apply the given
716 * command delay
717 */
718 if (!this->dev_ready) {
719 udelay (this->chip_delay);
720 return;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200721 }
Wolfgang Denk932394a2005-08-17 12:55:25 +0200722 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200723
Wolfgang Denk932394a2005-08-17 12:55:25 +0200724 /* Apply this short delay always to ensure that we do wait tWB in
725 * any case on any machine. */
726 ndelay (100);
727 /* wait until command is processed */
728 while (!this->dev_ready(mtd));
729}
730
731/**
732 * nand_get_device - [GENERIC] Get chip for selected access
733 * @this: the nand chip descriptor
734 * @mtd: MTD device structure
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200735 * @new_state: the state which is requested
Wolfgang Denk932394a2005-08-17 12:55:25 +0200736 *
737 * Get the device and lock it for exclusive access
738 */
739/* XXX U-BOOT XXX */
740#if 0
741static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state)
742{
743 struct nand_chip *active = this;
744
745 DECLARE_WAITQUEUE (wait, current);
746
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200747 /*
748 * Grab the lock and see if the device is available
Wolfgang Denk932394a2005-08-17 12:55:25 +0200749 */
750retry:
751 /* Hardware controller shared among independend devices */
752 if (this->controller) {
753 spin_lock (&this->controller->lock);
754 if (this->controller->active)
755 active = this->controller->active;
756 else
757 this->controller->active = this;
758 spin_unlock (&this->controller->lock);
759 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200760
Wolfgang Denk932394a2005-08-17 12:55:25 +0200761 if (active == this) {
762 spin_lock (&this->chip_lock);
763 if (this->state == FL_READY) {
764 this->state = new_state;
765 spin_unlock (&this->chip_lock);
766 return;
767 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200768 }
Wolfgang Denk932394a2005-08-17 12:55:25 +0200769 set_current_state (TASK_UNINTERRUPTIBLE);
770 add_wait_queue (&active->wq, &wait);
771 spin_unlock (&active->chip_lock);
772 schedule ();
773 remove_wait_queue (&active->wq, &wait);
774 goto retry;
775}
776#else
777static void nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state) {}
778#endif
779
780/**
781 * nand_wait - [DEFAULT] wait until the command is done
782 * @mtd: MTD device structure
783 * @this: NAND chip structure
784 * @state: state to select the max. timeout value
785 *
786 * Wait for command done. This applies to erase and program only
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200787 * Erase can take up to 400ms and program up to 20ms according to
Wolfgang Denk932394a2005-08-17 12:55:25 +0200788 * general NAND and SmartMedia specs
789 *
790*/
791/* XXX U-BOOT XXX */
792#if 0
793static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
794{
795 unsigned long timeo = jiffies;
796 int status;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200797
Wolfgang Denk932394a2005-08-17 12:55:25 +0200798 if (state == FL_ERASING)
799 timeo += (HZ * 400) / 1000;
800 else
801 timeo += (HZ * 20) / 1000;
802
803 /* Apply this short delay always to ensure that we do wait tWB in
804 * any case on any machine. */
805 ndelay (100);
806
807 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
808 this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200809 else
Wolfgang Denk932394a2005-08-17 12:55:25 +0200810 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1);
811
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200812 while (time_before(jiffies, timeo)) {
Wolfgang Denk932394a2005-08-17 12:55:25 +0200813 /* Check, if we were interrupted */
814 if (this->state != state)
815 return 0;
816
817 if (this->dev_ready) {
818 if (this->dev_ready(mtd))
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200819 break;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200820 } else {
821 if (this->read_byte(mtd) & NAND_STATUS_READY)
822 break;
823 }
824 yield ();
825 }
826 status = (int) this->read_byte(mtd);
827 return status;
828
829 return 0;
830}
831#else
832static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
833{
834 /* TODO */
835 return 0;
836}
837#endif
838
839/**
840 * nand_write_page - [GENERIC] write one page
841 * @mtd: MTD device structure
842 * @this: NAND chip structure
843 * @page: startpage inside the chip, must be called with (page & this->pagemask)
844 * @oob_buf: out of band data buffer
845 * @oobsel: out of band selecttion structre
846 * @cached: 1 = enable cached programming if supported by chip
847 *
848 * Nand_page_program function is used for write and writev !
849 * This function will always program a full page of data
850 * If you call it with a non page aligned buffer, you're lost :)
851 *
852 * Cached programming is not supported yet.
853 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200854static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page,
Wolfgang Denk932394a2005-08-17 12:55:25 +0200855 u_char *oob_buf, struct nand_oobinfo *oobsel, int cached)
856{
857 int i, status;
858 u_char ecc_code[32];
859 int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
860 int *oob_config = oobsel->eccpos;
861 int datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
862 int eccbytes = 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200863
Wolfgang Denk932394a2005-08-17 12:55:25 +0200864 /* FIXME: Enable cached programming */
865 cached = 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200866
Wolfgang Denk932394a2005-08-17 12:55:25 +0200867 /* Send command to begin auto page programming */
868 this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page);
869
870 /* Write out complete page of data, take care of eccmode */
871 switch (eccmode) {
872 /* No ecc, write all */
873 case NAND_ECC_NONE:
874 printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
875 this->write_buf(mtd, this->data_poi, mtd->oobblock);
876 break;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200877
Wolfgang Denk932394a2005-08-17 12:55:25 +0200878 /* Software ecc 3/256, write all */
879 case NAND_ECC_SOFT:
880 for (; eccsteps; eccsteps--) {
881 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
882 for (i = 0; i < 3; i++, eccidx++)
883 oob_buf[oob_config[eccidx]] = ecc_code[i];
884 datidx += this->eccsize;
885 }
886 this->write_buf(mtd, this->data_poi, mtd->oobblock);
887 break;
888 default:
889 eccbytes = this->eccbytes;
890 for (; eccsteps; eccsteps--) {
891 /* enable hardware ecc logic for write */
892 this->enable_hwecc(mtd, NAND_ECC_WRITE);
893 this->write_buf(mtd, &this->data_poi[datidx], this->eccsize);
894 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
895 for (i = 0; i < eccbytes; i++, eccidx++)
896 oob_buf[oob_config[eccidx]] = ecc_code[i];
897 /* If the hardware ecc provides syndromes then
898 * the ecc code must be written immidiately after
899 * the data bytes (words) */
900 if (this->options & NAND_HWECC_SYNDROME)
901 this->write_buf(mtd, ecc_code, eccbytes);
902 datidx += this->eccsize;
903 }
904 break;
905 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200906
Wolfgang Denk932394a2005-08-17 12:55:25 +0200907 /* Write out OOB data */
908 if (this->options & NAND_HWECC_SYNDROME)
909 this->write_buf(mtd, &oob_buf[oobsel->eccbytes], mtd->oobsize - oobsel->eccbytes);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200910 else
Wolfgang Denk932394a2005-08-17 12:55:25 +0200911 this->write_buf(mtd, oob_buf, mtd->oobsize);
912
913 /* Send command to actually program the data */
914 this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
915
916 if (!cached) {
917 /* call wait ready function */
918 status = this->waitfunc (mtd, this, FL_WRITING);
919 /* See if device thinks it succeeded */
920 if (status & 0x01) {
921 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
922 return -EIO;
923 }
924 } else {
925 /* FIXME: Implement cached programming ! */
926 /* wait until cache is ready*/
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200927 /* status = this->waitfunc (mtd, this, FL_CACHEDRPG); */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200928 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200929 return 0;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200930}
931
932#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
933/**
934 * nand_verify_pages - [GENERIC] verify the chip contents after a write
935 * @mtd: MTD device structure
936 * @this: NAND chip structure
937 * @page: startpage inside the chip, must be called with (page & this->pagemask)
938 * @numpages: number of pages to verify
939 * @oob_buf: out of band data buffer
940 * @oobsel: out of band selecttion structre
941 * @chipnr: number of the current chip
942 * @oobmode: 1 = full buffer verify, 0 = ecc only
943 *
944 * The NAND device assumes that it is always writing to a cleanly erased page.
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200945 * Hence, it performs its internal write verification only on bits that
Wolfgang Denk932394a2005-08-17 12:55:25 +0200946 * transitioned from 1 to 0. The device does NOT verify the whole page on a
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200947 * byte by byte basis. It is possible that the page was not completely erased
948 * or the page is becoming unusable due to wear. The read with ECC would catch
949 * the error later when the ECC page check fails, but we would rather catch
Wolfgang Denk932394a2005-08-17 12:55:25 +0200950 * it early in the page write stage. Better to write no data than invalid data.
951 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200952static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
Wolfgang Denk932394a2005-08-17 12:55:25 +0200953 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
954{
955 int i, j, datidx = 0, oobofs = 0, res = -EIO;
956 int eccsteps = this->eccsteps;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200957 int hweccbytes;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200958 u_char oobdata[64];
959
960 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
961
962 /* Send command to read back the first page */
963 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page);
964
965 for(;;) {
966 for (j = 0; j < eccsteps; j++) {
967 /* Loop through and verify the data */
968 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
969 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
970 goto out;
971 }
972 datidx += mtd->eccsize;
973 /* Have we a hw generator layout ? */
974 if (!hweccbytes)
975 continue;
976 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
977 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
978 goto out;
979 }
980 oobofs += hweccbytes;
981 }
982
983 /* check, if we must compare all data or if we just have to
984 * compare the ecc bytes
985 */
986 if (oobmode) {
987 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
988 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
989 goto out;
990 }
991 } else {
992 /* Read always, else autoincrement fails */
993 this->read_buf(mtd, oobdata, mtd->oobsize - hweccbytes * eccsteps);
994
995 if (oobsel->useecc != MTD_NANDECC_OFF && !hweccbytes) {
996 int ecccnt = oobsel->eccbytes;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +0200997
Wolfgang Denk932394a2005-08-17 12:55:25 +0200998 for (i = 0; i < ecccnt; i++) {
999 int idx = oobsel->eccpos[i];
1000 if (oobdata[idx] != oob_buf[oobofs + idx] ) {
1001 DEBUG (MTD_DEBUG_LEVEL0,
1002 "%s: Failed ECC write "
1003 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
1004 goto out;
1005 }
1006 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001007 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001008 }
1009 oobofs += mtd->oobsize - hweccbytes * eccsteps;
1010 page++;
1011 numpages--;
1012
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001013 /* Apply delay or wait for ready/busy pin
Wolfgang Denk932394a2005-08-17 12:55:25 +02001014 * Do this before the AUTOINCR check, so no problems
1015 * arise if a chip which does auto increment
1016 * is marked as NOAUTOINCR by the board driver.
1017 * Do this also before returning, so the chip is
1018 * ready for the next command.
1019 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001020 if (!this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001021 udelay (this->chip_delay);
1022 else
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001023 while (!this->dev_ready(mtd));
Wolfgang Denk932394a2005-08-17 12:55:25 +02001024
1025 /* All done, return happy */
1026 if (!numpages)
1027 return 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001028
1029
1030 /* Check, if the chip supports auto page increment */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001031 if (!NAND_CANAUTOINCR(this))
1032 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1033 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001034 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +02001035 * Terminate the read command. We come here in case of an error
1036 * So we must issue a reset command.
1037 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001038out:
Wolfgang Denk932394a2005-08-17 12:55:25 +02001039 this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1);
1040 return res;
1041}
1042#endif
1043
1044/**
1045 * nand_read - [MTD Interface] MTD compability function for nand_read_ecc
1046 * @mtd: MTD device structure
1047 * @from: offset to read from
1048 * @len: number of bytes to read
1049 * @retlen: pointer to variable to store the number of read bytes
1050 * @buf: the databuffer to put data
1051 *
1052 * This function simply calls nand_read_ecc with oob buffer and oobsel = NULL
1053*/
1054static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1055{
1056 return nand_read_ecc (mtd, from, len, retlen, buf, NULL, NULL);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001057}
Wolfgang Denk932394a2005-08-17 12:55:25 +02001058
1059
1060/**
1061 * nand_read_ecc - [MTD Interface] Read data with ECC
1062 * @mtd: MTD device structure
1063 * @from: offset to read from
1064 * @len: number of bytes to read
1065 * @retlen: pointer to variable to store the number of read bytes
1066 * @buf: the databuffer to put data
1067 * @oob_buf: filesystem supplied oob data buffer
1068 * @oobsel: oob selection structure
1069 *
1070 * NAND read with ECC
1071 */
1072static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1073 size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
1074{
1075 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
1076 int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
1077 struct nand_chip *this = mtd->priv;
1078 u_char *data_poi, *oob_data = oob_buf;
1079 u_char ecc_calc[32];
1080 u_char ecc_code[32];
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001081 int eccmode, eccsteps;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001082 int *oob_config, datidx;
1083 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1084 int eccbytes;
1085 int compareecc = 1;
1086 int oobreadlen;
1087
1088
1089 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1090
1091 /* Do not allow reads past end of device */
1092 if ((from + len) > mtd->size) {
1093 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1094 *retlen = 0;
1095 return -EINVAL;
1096 }
1097
1098 /* Grab the lock and see if the device is available */
1099 nand_get_device (this, mtd ,FL_READING);
1100
1101 /* use userspace supplied oobinfo, if zero */
1102 if (oobsel == NULL)
1103 oobsel = &mtd->oobinfo;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001104
Wolfgang Denk932394a2005-08-17 12:55:25 +02001105 /* Autoplace of oob data ? Use the default placement scheme */
1106 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
1107 oobsel = this->autooob;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001108
Wolfgang Denk932394a2005-08-17 12:55:25 +02001109 eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
1110 oob_config = oobsel->eccpos;
1111
1112 /* Select the NAND device */
1113 chipnr = (int)(from >> this->chip_shift);
1114 this->select_chip(mtd, chipnr);
1115
1116 /* First we calculate the starting page */
1117 realpage = (int) (from >> this->page_shift);
1118 page = realpage & this->pagemask;
1119
1120 /* Get raw starting column */
1121 col = from & (mtd->oobblock - 1);
1122
1123 end = mtd->oobblock;
1124 ecc = this->eccsize;
1125 eccbytes = this->eccbytes;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001126
Wolfgang Denk932394a2005-08-17 12:55:25 +02001127 if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
1128 compareecc = 0;
1129
1130 oobreadlen = mtd->oobsize;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001131 if (this->options & NAND_HWECC_SYNDROME)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001132 oobreadlen -= oobsel->eccbytes;
1133
1134 /* Loop until all data read */
1135 while (read < len) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001136
Wolfgang Denk932394a2005-08-17 12:55:25 +02001137 int aligned = (!col && (len - read) >= end);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001138 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +02001139 * If the read is not page aligned, we have to read into data buffer
1140 * due to ecc, else we read into return buffer direct
1141 */
1142 if (aligned)
1143 data_poi = &buf[read];
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001144 else
Wolfgang Denk932394a2005-08-17 12:55:25 +02001145 data_poi = this->data_buf;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001146
1147 /* Check, if we have this page in the buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +02001148 *
1149 * FIXME: Make it work when we must provide oob data too,
1150 * check the usage of data_buf oob field
1151 */
1152 if (realpage == this->pagebuf && !oob_buf) {
1153 /* aligned read ? */
1154 if (aligned)
1155 memcpy (data_poi, this->data_buf, end);
1156 goto readdata;
1157 }
1158
1159 /* Check, if we must send the read command */
1160 if (sndcmd) {
1161 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
1162 sndcmd = 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001163 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001164
1165 /* get oob area, if we have no oob buffer from fs-driver */
1166 if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
1167 oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1168 oob_data = &this->data_buf[end];
1169
1170 eccsteps = this->eccsteps;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001171
Wolfgang Denk932394a2005-08-17 12:55:25 +02001172 switch (eccmode) {
1173 case NAND_ECC_NONE: { /* No ECC, Read in a page */
1174/* XXX U-BOOT XXX */
1175#if 0
1176 static unsigned long lastwhinge = 0;
1177 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1178 printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
1179 lastwhinge = jiffies;
1180 }
1181#else
1182 puts("Reading data from NAND FLASH without ECC is not recommended\n");
1183#endif
1184 this->read_buf(mtd, data_poi, end);
1185 break;
1186 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001187
Wolfgang Denk932394a2005-08-17 12:55:25 +02001188 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1189 this->read_buf(mtd, data_poi, end);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001190 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001191 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001192 break;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001193
1194 default:
1195 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
1196 this->enable_hwecc(mtd, NAND_ECC_READ);
1197 this->read_buf(mtd, &data_poi[datidx], ecc);
1198
1199 /* HW ecc with syndrome calculation must read the
1200 * syndrome from flash immidiately after the data */
1201 if (!compareecc) {
1202 /* Some hw ecc generators need to know when the
1203 * syndrome is read from flash */
1204 this->enable_hwecc(mtd, NAND_ECC_READSYN);
1205 this->read_buf(mtd, &oob_data[i], eccbytes);
1206 /* We calc error correction directly, it checks the hw
1207 * generator for an error, reads back the syndrome and
1208 * does the error correction on the fly */
1209 if (this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]) == -1) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001210 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
Wolfgang Denk932394a2005-08-17 12:55:25 +02001211 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1212 ecc_failed++;
1213 }
1214 } else {
1215 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001216 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001217 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001218 break;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001219 }
1220
1221 /* read oobdata */
1222 this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
1223
1224 /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
1225 if (!compareecc)
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001226 goto readoob;
1227
Wolfgang Denk932394a2005-08-17 12:55:25 +02001228 /* Pick the ECC bytes out of the oob data */
1229 for (j = 0; j < oobsel->eccbytes; j++)
1230 ecc_code[j] = oob_data[oob_config[j]];
1231
1232 /* correct data, if neccecary */
1233 for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
1234 ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001235
Wolfgang Denk932394a2005-08-17 12:55:25 +02001236 /* Get next chunk of ecc bytes */
1237 j += eccbytes;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001238
1239 /* Check, if we have a fs supplied oob-buffer,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001240 * This is the legacy mode. Used by YAFFS1
1241 * Should go away some day
1242 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001243 if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
Wolfgang Denk932394a2005-08-17 12:55:25 +02001244 int *p = (int *)(&oob_data[mtd->oobsize]);
1245 p[i] = ecc_status;
1246 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001247
1248 if (ecc_status == -1) {
Wolfgang Denk932394a2005-08-17 12:55:25 +02001249 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1250 ecc_failed++;
1251 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001252 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001253
1254 readoob:
1255 /* check, if we have a fs supplied oob-buffer */
1256 if (oob_buf) {
1257 /* without autoplace. Legacy mode used by YAFFS1 */
1258 switch(oobsel->useecc) {
1259 case MTD_NANDECC_AUTOPLACE:
1260 case MTD_NANDECC_AUTOPL_USR:
1261 /* Walk through the autoplace chunks */
1262 for (i = 0, j = 0; j < mtd->oobavail; i++) {
1263 int from = oobsel->oobfree[i][0];
1264 int num = oobsel->oobfree[i][1];
1265 memcpy(&oob_buf[oob], &oob_data[from], num);
1266 j+= num;
1267 }
1268 oob += mtd->oobavail;
1269 break;
1270 case MTD_NANDECC_PLACE:
1271 /* YAFFS1 legacy mode */
1272 oob_data += this->eccsteps * sizeof (int);
1273 default:
1274 oob_data += mtd->oobsize;
1275 }
1276 }
1277 readdata:
1278 /* Partial page read, transfer data into fs buffer */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001279 if (!aligned) {
Wolfgang Denk932394a2005-08-17 12:55:25 +02001280 for (j = col; j < end && read < len; j++)
1281 buf[read++] = data_poi[j];
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001282 this->pagebuf = realpage;
1283 } else
Wolfgang Denk932394a2005-08-17 12:55:25 +02001284 read += mtd->oobblock;
1285
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001286 /* Apply delay or wait for ready/busy pin
Wolfgang Denk932394a2005-08-17 12:55:25 +02001287 * Do this before the AUTOINCR check, so no problems
1288 * arise if a chip which does auto increment
1289 * is marked as NOAUTOINCR by the board driver.
1290 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001291 if (!this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001292 udelay (this->chip_delay);
1293 else
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001294 while (!this->dev_ready(mtd));
1295
Wolfgang Denk932394a2005-08-17 12:55:25 +02001296 if (read == len)
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001297 break;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001298
1299 /* For subsequent reads align to page boundary. */
1300 col = 0;
1301 /* Increment page address */
1302 realpage++;
1303
1304 page = realpage & this->pagemask;
1305 /* Check, if we cross a chip boundary */
1306 if (!page) {
1307 chipnr++;
1308 this->select_chip(mtd, -1);
1309 this->select_chip(mtd, chipnr);
1310 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001311 /* Check, if the chip supports auto page increment
1312 * or if we have hit a block boundary.
1313 */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001314 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001315 sndcmd = 1;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001316 }
1317
1318 /* Deselect and wake up anyone waiting on the device */
1319 nand_release_device(mtd);
1320
1321 /*
1322 * Return success, if no ECC failures, else -EBADMSG
1323 * fs driver will take care of that, because
1324 * retlen == desired len and result == -EBADMSG
1325 */
1326 *retlen = read;
1327 return ecc_failed ? -EBADMSG : 0;
1328}
1329
1330/**
1331 * nand_read_oob - [MTD Interface] NAND read out-of-band
1332 * @mtd: MTD device structure
1333 * @from: offset to read from
1334 * @len: number of bytes to read
1335 * @retlen: pointer to variable to store the number of read bytes
1336 * @buf: the databuffer to put data
1337 *
1338 * NAND read out-of-band data from the spare area
1339 */
1340static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
1341{
1342 int i, col, page, chipnr;
1343 struct nand_chip *this = mtd->priv;
1344 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1345
1346 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1347
1348 /* Shift to get page */
1349 page = (int)(from >> this->page_shift);
1350 chipnr = (int)(from >> this->chip_shift);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001351
Wolfgang Denk932394a2005-08-17 12:55:25 +02001352 /* Mask to get column */
1353 col = from & (mtd->oobsize - 1);
1354
1355 /* Initialize return length value */
1356 *retlen = 0;
1357
1358 /* Do not allow reads past end of device */
1359 if ((from + len) > mtd->size) {
1360 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1361 *retlen = 0;
1362 return -EINVAL;
1363 }
1364
1365 /* Grab the lock and see if the device is available */
1366 nand_get_device (this, mtd , FL_READING);
1367
1368 /* Select the NAND device */
1369 this->select_chip(mtd, chipnr);
1370
1371 /* Send the read command */
1372 this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001373 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +02001374 * Read the data, if we read more than one page
1375 * oob data, let the device transfer the data !
1376 */
1377 i = 0;
1378 while (i < len) {
1379 int thislen = mtd->oobsize - col;
1380 thislen = min_t(int, thislen, len);
1381 this->read_buf(mtd, &buf[i], thislen);
1382 i += thislen;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001383
1384 /* Apply delay or wait for ready/busy pin
Wolfgang Denk932394a2005-08-17 12:55:25 +02001385 * Do this before the AUTOINCR check, so no problems
1386 * arise if a chip which does auto increment
1387 * is marked as NOAUTOINCR by the board driver.
1388 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001389 if (!this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001390 udelay (this->chip_delay);
1391 else
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001392 while (!this->dev_ready(mtd));
Wolfgang Denk932394a2005-08-17 12:55:25 +02001393
1394 /* Read more ? */
1395 if (i < len) {
1396 page++;
1397 col = 0;
1398
1399 /* Check, if we cross a chip boundary */
1400 if (!(page & this->pagemask)) {
1401 chipnr++;
1402 this->select_chip(mtd, -1);
1403 this->select_chip(mtd, chipnr);
1404 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001405
1406 /* Check, if the chip supports auto page increment
1407 * or if we have hit a block boundary.
1408 */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001409 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1410 /* For subsequent page reads set offset to 0 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001411 this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
Wolfgang Denk932394a2005-08-17 12:55:25 +02001412 }
1413 }
1414 }
1415
1416 /* Deselect and wake up anyone waiting on the device */
1417 nand_release_device(mtd);
1418
1419 /* Return happy */
1420 *retlen = len;
1421 return 0;
1422}
1423
1424/**
1425 * nand_read_raw - [GENERIC] Read raw data including oob into buffer
1426 * @mtd: MTD device structure
1427 * @buf: temporary buffer
1428 * @from: offset to read from
1429 * @len: number of bytes to read
1430 * @ooblen: number of oob data bytes to read
1431 *
1432 * Read raw data including oob into buffer
1433 */
1434int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1435{
1436 struct nand_chip *this = mtd->priv;
1437 int page = (int) (from >> this->page_shift);
1438 int chip = (int) (from >> this->chip_shift);
1439 int sndcmd = 1;
1440 int cnt = 0;
1441 int pagesize = mtd->oobblock + mtd->oobsize;
1442 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1443
1444 /* Do not allow reads past end of device */
1445 if ((from + len) > mtd->size) {
1446 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1447 return -EINVAL;
1448 }
1449
1450 /* Grab the lock and see if the device is available */
1451 nand_get_device (this, mtd , FL_READING);
1452
1453 this->select_chip (mtd, chip);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001454
Wolfgang Denk932394a2005-08-17 12:55:25 +02001455 /* Add requested oob length */
1456 len += ooblen;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001457
Wolfgang Denk932394a2005-08-17 12:55:25 +02001458 while (len) {
1459 if (sndcmd)
1460 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001461 sndcmd = 0;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001462
1463 this->read_buf (mtd, &buf[cnt], pagesize);
1464
1465 len -= pagesize;
1466 cnt += pagesize;
1467 page++;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001468
1469 if (!this->dev_ready)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001470 udelay (this->chip_delay);
1471 else
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001472 while (!this->dev_ready(mtd));
1473
1474 /* Check, if the chip supports auto page increment */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001475 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1476 sndcmd = 1;
1477 }
1478
1479 /* Deselect and wake up anyone waiting on the device */
1480 nand_release_device(mtd);
1481 return 0;
1482}
1483
1484
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001485/**
1486 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
Wolfgang Denk932394a2005-08-17 12:55:25 +02001487 * @mtd: MTD device structure
1488 * @fsbuf: buffer given by fs driver
1489 * @oobsel: out of band selection structre
1490 * @autoplace: 1 = place given buffer into the oob bytes
1491 * @numpages: number of pages to prepare
1492 *
1493 * Return:
1494 * 1. Filesystem buffer available and autoplacement is off,
1495 * return filesystem buffer
1496 * 2. No filesystem buffer or autoplace is off, return internal
1497 * buffer
1498 * 3. Filesystem buffer is given and autoplace selected
1499 * put data from fs buffer into internal buffer and
1500 * retrun internal buffer
1501 *
1502 * Note: The internal buffer is filled with 0xff. This must
1503 * be done only once, when no autoplacement happens
1504 * Autoplacement sets the buffer dirty flag, which
1505 * forces the 0xff fill before using the buffer again.
1506 *
1507*/
1508static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
1509 int autoplace, int numpages)
1510{
1511 struct nand_chip *this = mtd->priv;
1512 int i, len, ofs;
1513
1514 /* Zero copy fs supplied buffer */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001515 if (fsbuf && !autoplace)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001516 return fsbuf;
1517
1518 /* Check, if the buffer must be filled with ff again */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001519 if (this->oobdirty) {
1520 memset (this->oob_buf, 0xff,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001521 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1522 this->oobdirty = 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001523 }
1524
Wolfgang Denk932394a2005-08-17 12:55:25 +02001525 /* If we have no autoplacement or no fs buffer use the internal one */
1526 if (!autoplace || !fsbuf)
1527 return this->oob_buf;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001528
Wolfgang Denk932394a2005-08-17 12:55:25 +02001529 /* Walk through the pages and place the data */
1530 this->oobdirty = 1;
1531 ofs = 0;
1532 while (numpages--) {
1533 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1534 int to = ofs + oobsel->oobfree[i][0];
1535 int num = oobsel->oobfree[i][1];
1536 memcpy (&this->oob_buf[to], fsbuf, num);
1537 len += num;
1538 fsbuf += num;
1539 }
1540 ofs += mtd->oobavail;
1541 }
1542 return this->oob_buf;
1543}
1544
1545#define NOTALIGNED(x) (x & (mtd->oobblock-1)) != 0
1546
1547/**
1548 * nand_write - [MTD Interface] compability function for nand_write_ecc
1549 * @mtd: MTD device structure
1550 * @to: offset to write to
1551 * @len: number of bytes to write
1552 * @retlen: pointer to variable to store the number of written bytes
1553 * @buf: the data to write
1554 *
1555 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1556 *
1557*/
1558static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1559{
1560 return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL));
1561}
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001562
Wolfgang Denk932394a2005-08-17 12:55:25 +02001563/**
1564 * nand_write_ecc - [MTD Interface] NAND write with ECC
1565 * @mtd: MTD device structure
1566 * @to: offset to write to
1567 * @len: number of bytes to write
1568 * @retlen: pointer to variable to store the number of written bytes
1569 * @buf: the data to write
1570 * @eccbuf: filesystem supplied oob data buffer
1571 * @oobsel: oob selection structure
1572 *
1573 * NAND write with ECC
1574 */
1575static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1576 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel)
1577{
1578 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1579 int autoplace = 0, numpages, totalpages;
1580 struct nand_chip *this = mtd->priv;
1581 u_char *oobbuf, *bufstart;
1582 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1583
1584 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1585
1586 /* Initialize retlen, in case of early exit */
1587 *retlen = 0;
1588
1589 /* Do not allow write past end of device */
1590 if ((to + len) > mtd->size) {
1591 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
1592 return -EINVAL;
1593 }
1594
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001595 /* reject writes, which are not page aligned */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001596 if (NOTALIGNED (to) || NOTALIGNED(len)) {
1597 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1598 return -EINVAL;
1599 }
1600
1601 /* Grab the lock and see if the device is available */
1602 nand_get_device (this, mtd, FL_WRITING);
1603
1604 /* Calculate chipnr */
1605 chipnr = (int)(to >> this->chip_shift);
1606 /* Select the NAND device */
1607 this->select_chip(mtd, chipnr);
1608
1609 /* Check, if it is write protected */
1610 if (nand_check_wp(mtd))
1611 goto out;
1612
1613 /* if oobsel is NULL, use chip defaults */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001614 if (oobsel == NULL)
1615 oobsel = &mtd->oobinfo;
1616
Wolfgang Denk932394a2005-08-17 12:55:25 +02001617 /* Autoplace of oob data ? Use the default placement scheme */
1618 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1619 oobsel = this->autooob;
1620 autoplace = 1;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001621 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001622 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1623 autoplace = 1;
1624
1625 /* Setup variables and oob buffer */
1626 totalpages = len >> this->page_shift;
1627 page = (int) (to >> this->page_shift);
1628 /* Invalidate the page cache, if we write to the cached page */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001629 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
Wolfgang Denk932394a2005-08-17 12:55:25 +02001630 this->pagebuf = -1;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001631
Wolfgang Denk932394a2005-08-17 12:55:25 +02001632 /* Set it relative to chip */
1633 page &= this->pagemask;
1634 startpage = page;
1635 /* Calc number of pages we can write in one go */
1636 numpages = min (ppblock - (startpage & (ppblock - 1)), totalpages);
1637 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages);
1638 bufstart = (u_char *)buf;
1639
1640 /* Loop until all data is written */
1641 while (written < len) {
1642
1643 this->data_poi = (u_char*) &buf[written];
1644 /* Write one page. If this is the last page to write
1645 * or the last page in this block, then use the
1646 * real pageprogram command, else select cached programming
1647 * if supported by the chip.
1648 */
1649 ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1650 if (ret) {
1651 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1652 goto out;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001653 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001654 /* Next oob page */
1655 oob += mtd->oobsize;
1656 /* Update written bytes count */
1657 written += mtd->oobblock;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001658 if (written == len)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001659 goto cmp;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001660
Wolfgang Denk932394a2005-08-17 12:55:25 +02001661 /* Increment page address */
1662 page++;
1663
1664 /* Have we hit a block boundary ? Then we have to verify and
1665 * if verify is ok, we have to setup the oob buffer for
1666 * the next pages.
1667 */
1668 if (!(page & (ppblock - 1))){
1669 int ofs;
1670 this->data_poi = bufstart;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001671 ret = nand_verify_pages (mtd, this, startpage,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001672 page - startpage,
1673 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1674 if (ret) {
1675 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1676 goto out;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001677 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001678 *retlen = written;
1679
1680 ofs = autoplace ? mtd->oobavail : mtd->oobsize;
1681 if (eccbuf)
1682 eccbuf += (page - startpage) * ofs;
1683 totalpages -= page - startpage;
1684 numpages = min (totalpages, ppblock);
1685 page &= this->pagemask;
1686 startpage = page;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001687 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001688 autoplace, numpages);
1689 /* Check, if we cross a chip boundary */
1690 if (!page) {
1691 chipnr++;
1692 this->select_chip(mtd, -1);
1693 this->select_chip(mtd, chipnr);
1694 }
1695 }
1696 }
1697 /* Verify the remaining pages */
1698cmp:
1699 this->data_poi = bufstart;
1700 ret = nand_verify_pages (mtd, this, startpage, totalpages,
1701 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1702 if (!ret)
1703 *retlen = written;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001704 else
Wolfgang Denk932394a2005-08-17 12:55:25 +02001705 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1706
1707out:
1708 /* Deselect and wake up anyone waiting on the device */
1709 nand_release_device(mtd);
1710
1711 return ret;
1712}
1713
1714
1715/**
1716 * nand_write_oob - [MTD Interface] NAND write out-of-band
1717 * @mtd: MTD device structure
1718 * @to: offset to write to
1719 * @len: number of bytes to write
1720 * @retlen: pointer to variable to store the number of written bytes
1721 * @buf: the data to write
1722 *
1723 * NAND write out-of-band
1724 */
1725static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf)
1726{
1727 int column, page, status, ret = -EIO, chipnr;
1728 struct nand_chip *this = mtd->priv;
1729
1730 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len);
1731
1732 /* Shift to get page */
1733 page = (int) (to >> this->page_shift);
1734 chipnr = (int) (to >> this->chip_shift);
1735
1736 /* Mask to get column */
1737 column = to & (mtd->oobsize - 1);
1738
1739 /* Initialize return length value */
1740 *retlen = 0;
1741
1742 /* Do not allow write past end of page */
1743 if ((column + len) > mtd->oobsize) {
1744 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1745 return -EINVAL;
1746 }
1747
1748 /* Grab the lock and see if the device is available */
1749 nand_get_device (this, mtd, FL_WRITING);
1750
1751 /* Select the NAND device */
1752 this->select_chip(mtd, chipnr);
1753
1754 /* Reset the chip. Some chips (like the Toshiba TC5832DC found
1755 in one of my DiskOnChip 2000 test units) will clear the whole
1756 data page too if we don't do this. I have no clue why, but
1757 I seem to have 'fixed' it in the doc2000 driver in
1758 August 1999. dwmw2. */
1759 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1760
1761 /* Check, if it is write protected */
1762 if (nand_check_wp(mtd))
1763 goto out;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001764
Wolfgang Denk932394a2005-08-17 12:55:25 +02001765 /* Invalidate the page cache, if we write to the cached page */
1766 if (page == this->pagebuf)
1767 this->pagebuf = -1;
1768
1769 if (NAND_MUST_PAD(this)) {
1770 /* Write out desired data */
1771 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1772 /* prepad 0xff for partial programming */
1773 this->write_buf(mtd, ffchars, column);
1774 /* write data */
1775 this->write_buf(mtd, buf, len);
1776 /* postpad 0xff for partial programming */
1777 this->write_buf(mtd, ffchars, mtd->oobsize - (len+column));
1778 } else {
1779 /* Write out desired data */
1780 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1781 /* write data */
1782 this->write_buf(mtd, buf, len);
1783 }
1784 /* Send command to program the OOB data */
1785 this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1);
1786
1787 status = this->waitfunc (mtd, this, FL_WRITING);
1788
1789 /* See if device thinks it succeeded */
1790 if (status & 0x01) {
1791 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1792 ret = -EIO;
1793 goto out;
1794 }
1795 /* Return happy */
1796 *retlen = len;
1797
1798#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1799 /* Send command to read back the data */
1800 this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1801
1802 if (this->verify_buf(mtd, buf, len)) {
1803 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1804 ret = -EIO;
1805 goto out;
1806 }
1807#endif
1808 ret = 0;
1809out:
1810 /* Deselect and wake up anyone waiting on the device */
1811 nand_release_device(mtd);
1812
1813 return ret;
1814}
1815
1816/* XXX U-BOOT XXX */
1817#if 0
1818/**
1819 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1820 * @mtd: MTD device structure
1821 * @vecs: the iovectors to write
1822 * @count: number of vectors
1823 * @to: offset to write to
1824 * @retlen: pointer to variable to store the number of written bytes
1825 *
1826 * NAND write with kvec. This just calls the ecc function
1827 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001828static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001829 loff_t to, size_t * retlen)
1830{
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001831 return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL));
Wolfgang Denk932394a2005-08-17 12:55:25 +02001832}
1833
1834/**
1835 * nand_writev_ecc - [MTD Interface] write with iovec with ecc
1836 * @mtd: MTD device structure
1837 * @vecs: the iovectors to write
1838 * @count: number of vectors
1839 * @to: offset to write to
1840 * @retlen: pointer to variable to store the number of written bytes
1841 * @eccbuf: filesystem supplied oob data buffer
1842 * @oobsel: oob selection structure
1843 *
1844 * NAND write with iovec with ecc
1845 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001846static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001847 loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
1848{
1849 int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1850 int oob, numpages, autoplace = 0, startpage;
1851 struct nand_chip *this = mtd->priv;
1852 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1853 u_char *oobbuf, *bufstart;
1854
1855 /* Preset written len for early exit */
1856 *retlen = 0;
1857
1858 /* Calculate total length of data */
1859 total_len = 0;
1860 for (i = 0; i < count; i++)
1861 total_len += (int) vecs[i].iov_len;
1862
1863 DEBUG (MTD_DEBUG_LEVEL3,
1864 "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
1865
1866 /* Do not allow write past end of page */
1867 if ((to + total_len) > mtd->size) {
1868 DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1869 return -EINVAL;
1870 }
1871
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001872 /* reject writes, which are not page aligned */
Wolfgang Denk932394a2005-08-17 12:55:25 +02001873 if (NOTALIGNED (to) || NOTALIGNED(total_len)) {
1874 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1875 return -EINVAL;
1876 }
1877
1878 /* Grab the lock and see if the device is available */
1879 nand_get_device (this, mtd, FL_WRITING);
1880
1881 /* Get the current chip-nr */
1882 chipnr = (int) (to >> this->chip_shift);
1883 /* Select the NAND device */
1884 this->select_chip(mtd, chipnr);
1885
1886 /* Check, if it is write protected */
1887 if (nand_check_wp(mtd))
1888 goto out;
1889
1890 /* if oobsel is NULL, use chip defaults */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001891 if (oobsel == NULL)
1892 oobsel = &mtd->oobinfo;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001893
1894 /* Autoplace of oob data ? Use the default placement scheme */
1895 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) {
1896 oobsel = this->autooob;
1897 autoplace = 1;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001898 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02001899 if (oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
1900 autoplace = 1;
1901
1902 /* Setup start page */
1903 page = (int) (to >> this->page_shift);
1904 /* Invalidate the page cache, if we write to the cached page */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001905 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
Wolfgang Denk932394a2005-08-17 12:55:25 +02001906 this->pagebuf = -1;
1907
1908 startpage = page & this->pagemask;
1909
1910 /* Loop until all kvec' data has been written */
1911 len = 0;
1912 while (count) {
1913 /* If the given tuple is >= pagesize then
1914 * write it out from the iov
1915 */
1916 if ((vecs->iov_len - len) >= mtd->oobblock) {
1917 /* Calc number of pages we can write
1918 * out of this iov in one go */
1919 numpages = (vecs->iov_len - len) >> this->page_shift;
1920 /* Do not cross block boundaries */
1921 numpages = min (ppblock - (startpage & (ppblock - 1)), numpages);
1922 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1923 bufstart = (u_char *)vecs->iov_base;
1924 bufstart += len;
1925 this->data_poi = bufstart;
1926 oob = 0;
1927 for (i = 1; i <= numpages; i++) {
1928 /* Write one page. If this is the last page to write
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001929 * then use the real pageprogram command, else select
Wolfgang Denk932394a2005-08-17 12:55:25 +02001930 * cached programming if supported by the chip.
1931 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001932 ret = nand_write_page (mtd, this, page & this->pagemask,
Wolfgang Denk932394a2005-08-17 12:55:25 +02001933 &oobbuf[oob], oobsel, i != numpages);
1934 if (ret)
1935 goto out;
1936 this->data_poi += mtd->oobblock;
1937 len += mtd->oobblock;
1938 oob += mtd->oobsize;
1939 page++;
1940 }
1941 /* Check, if we have to switch to the next tuple */
1942 if (len >= (int) vecs->iov_len) {
1943 vecs++;
1944 len = 0;
1945 count--;
1946 }
1947 } else {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001948 /* We must use the internal buffer, read data out of each
Wolfgang Denk932394a2005-08-17 12:55:25 +02001949 * tuple until we have a full page to write
1950 */
1951 int cnt = 0;
1952 while (cnt < mtd->oobblock) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001953 if (vecs->iov_base != NULL && vecs->iov_len)
Wolfgang Denk932394a2005-08-17 12:55:25 +02001954 this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
1955 /* Check, if we have to switch to the next tuple */
1956 if (len >= (int) vecs->iov_len) {
1957 vecs++;
1958 len = 0;
1959 count--;
1960 }
1961 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001962 this->pagebuf = page;
1963 this->data_poi = this->data_buf;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001964 bufstart = this->data_poi;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001965 numpages = 1;
Wolfgang Denk932394a2005-08-17 12:55:25 +02001966 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages);
1967 ret = nand_write_page (mtd, this, page & this->pagemask,
1968 oobbuf, oobsel, 0);
1969 if (ret)
1970 goto out;
1971 page++;
1972 }
1973
1974 this->data_poi = bufstart;
1975 ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
1976 if (ret)
1977 goto out;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02001978
Wolfgang Denk932394a2005-08-17 12:55:25 +02001979 written += mtd->oobblock * numpages;
1980 /* All done ? */
1981 if (!count)
1982 break;
1983
1984 startpage = page & this->pagemask;
1985 /* Check, if we cross a chip boundary */
1986 if (!startpage) {
1987 chipnr++;
1988 this->select_chip(mtd, -1);
1989 this->select_chip(mtd, chipnr);
1990 }
1991 }
1992 ret = 0;
1993out:
1994 /* Deselect and wake up anyone waiting on the device */
1995 nand_release_device(mtd);
1996
1997 *retlen = written;
1998 return ret;
1999}
2000#endif
2001
2002/**
2003 * single_erease_cmd - [GENERIC] NAND standard block erase command function
2004 * @mtd: MTD device structure
2005 * @page: the page address of the block which will be erased
2006 *
2007 * Standard erase command for NAND chips
2008 */
2009static void single_erase_cmd (struct mtd_info *mtd, int page)
2010{
2011 struct nand_chip *this = mtd->priv;
2012 /* Send commands to erase a block */
2013 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2014 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2015}
2016
2017/**
2018 * multi_erease_cmd - [GENERIC] AND specific block erase command function
2019 * @mtd: MTD device structure
2020 * @page: the page address of the block which will be erased
2021 *
2022 * AND multi block erase command function
2023 * Erase 4 consecutive blocks
2024 */
2025static void multi_erase_cmd (struct mtd_info *mtd, int page)
2026{
2027 struct nand_chip *this = mtd->priv;
2028 /* Send commands to erase a block */
2029 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2030 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2031 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++);
2032 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page);
2033 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1);
2034}
2035
2036/**
2037 * nand_erase - [MTD Interface] erase block(s)
2038 * @mtd: MTD device structure
2039 * @instr: erase instruction
2040 *
2041 * Erase one ore more blocks
2042 */
2043static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
2044{
2045 return nand_erase_nand (mtd, instr, 0);
2046}
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002047
Wolfgang Denk932394a2005-08-17 12:55:25 +02002048/**
2049 * nand_erase_intern - [NAND Interface] erase block(s)
2050 * @mtd: MTD device structure
2051 * @instr: erase instruction
2052 * @allowbbt: allow erasing the bbt area
2053 *
2054 * Erase one ore more blocks
2055 */
2056int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2057{
2058 int page, len, status, pages_per_block, ret, chipnr;
2059 struct nand_chip *this = mtd->priv;
2060
2061 DEBUG (MTD_DEBUG_LEVEL3,
2062 "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
2063
2064 /* Start address must align on block boundary */
2065 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2066 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2067 return -EINVAL;
2068 }
2069
2070 /* Length must align on block boundary */
2071 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2072 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2073 return -EINVAL;
2074 }
2075
2076 /* Do not allow erase past end of device */
2077 if ((instr->len + instr->addr) > mtd->size) {
2078 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2079 return -EINVAL;
2080 }
2081
2082 instr->fail_addr = 0xffffffff;
2083
2084 /* Grab the lock and see if the device is available */
2085 nand_get_device (this, mtd, FL_ERASING);
2086
2087 /* Shift to get first page */
2088 page = (int) (instr->addr >> this->page_shift);
2089 chipnr = (int) (instr->addr >> this->chip_shift);
2090
2091 /* Calculate pages in each block */
2092 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
2093
2094 /* Select the NAND device */
2095 this->select_chip(mtd, chipnr);
2096
2097 /* Check the WP bit */
2098 /* Check, if it is write protected */
2099 if (nand_check_wp(mtd)) {
2100 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2101 instr->state = MTD_ERASE_FAILED;
2102 goto erase_exit;
2103 }
2104
2105 /* Loop through the pages */
2106 len = instr->len;
2107
2108 instr->state = MTD_ERASING;
2109
2110 while (len) {
2111 /* Check if we have a bad block, we do not erase bad blocks ! */
2112 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2113 printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2114 instr->state = MTD_ERASE_FAILED;
2115 goto erase_exit;
2116 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002117
2118 /* Invalidate the page cache, if we erase the block which contains
Wolfgang Denk932394a2005-08-17 12:55:25 +02002119 the current cached page */
2120 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2121 this->pagebuf = -1;
2122
2123 this->erase_cmd (mtd, page & this->pagemask);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002124
Wolfgang Denk932394a2005-08-17 12:55:25 +02002125 status = this->waitfunc (mtd, this, FL_ERASING);
2126
2127 /* See if block erase succeeded */
2128 if (status & 0x01) {
2129 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2130 instr->state = MTD_ERASE_FAILED;
2131 instr->fail_addr = (page << this->page_shift);
2132 goto erase_exit;
2133 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002134
Wolfgang Denk932394a2005-08-17 12:55:25 +02002135 /* Increment page address and decrement length */
2136 len -= (1 << this->phys_erase_shift);
2137 page += pages_per_block;
2138
2139 /* Check, if we cross a chip boundary */
2140 if (len && !(page & this->pagemask)) {
2141 chipnr++;
2142 this->select_chip(mtd, -1);
2143 this->select_chip(mtd, chipnr);
2144 }
2145 }
2146 instr->state = MTD_ERASE_DONE;
2147
2148erase_exit:
2149
2150 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2151 /* Do call back function */
2152 if (!ret)
2153 mtd_erase_callback(instr);
2154
2155 /* Deselect and wake up anyone waiting on the device */
2156 nand_release_device(mtd);
2157
2158 /* Return more or less happy */
2159 return ret;
2160}
2161
2162/**
2163 * nand_sync - [MTD Interface] sync
2164 * @mtd: MTD device structure
2165 *
2166 * Sync is actually a wait for chip ready function
2167 */
2168static void nand_sync (struct mtd_info *mtd)
2169{
2170 struct nand_chip *this = mtd->priv;
2171
2172 DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2173
2174 /* Grab the lock and see if the device is available */
2175 nand_get_device (this, mtd, FL_SYNCING);
2176 /* Release it and go back */
2177 nand_release_device (mtd);
2178}
2179
2180
2181/**
2182 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2183 * @mtd: MTD device structure
2184 * @ofs: offset relative to mtd start
2185 */
2186static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
2187{
2188 /* Check for invalid offset */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002189 if (ofs > mtd->size)
Wolfgang Denk932394a2005-08-17 12:55:25 +02002190 return -EINVAL;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002191
Wolfgang Denk932394a2005-08-17 12:55:25 +02002192 return nand_block_checkbad (mtd, ofs, 1, 0);
2193}
2194
2195/**
2196 * nand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
2197 * @mtd: MTD device structure
2198 * @ofs: offset relative to mtd start
2199 */
2200static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs)
2201{
2202 struct nand_chip *this = mtd->priv;
2203 int ret;
2204
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002205 if ((ret = nand_block_isbad(mtd, ofs))) {
2206 /* If it was bad already, return success and do nothing. */
Wolfgang Denk932394a2005-08-17 12:55:25 +02002207 if (ret > 0)
2208 return 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002209 return ret;
2210 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02002211
2212 return this->block_markbad(mtd, ofs);
2213}
2214
2215/**
2216 * nand_scan - [NAND Interface] Scan for the NAND device
2217 * @mtd: MTD device structure
2218 * @maxchips: Number of chips to scan for
2219 *
2220 * This fills out all the not initialized function pointers
2221 * with the defaults.
2222 * The flash ID is read and the mtd/chip structures are
2223 * filled with the appropriate values. Buffers are allocated if
2224 * they are not provided by the board driver
2225 *
2226 */
2227int nand_scan (struct mtd_info *mtd, int maxchips)
2228{
2229 int i, j, nand_maf_id, nand_dev_id, busw;
2230 struct nand_chip *this = mtd->priv;
2231
2232 /* Get buswidth to select the correct functions*/
2233 busw = this->options & NAND_BUSWIDTH_16;
2234
2235 /* check for proper chip_delay setup, set 20us if not */
2236 if (!this->chip_delay)
2237 this->chip_delay = 20;
2238
2239 /* check, if a user supplied command function given */
2240 if (this->cmdfunc == NULL)
2241 this->cmdfunc = nand_command;
2242
2243 /* check, if a user supplied wait function given */
2244 if (this->waitfunc == NULL)
2245 this->waitfunc = nand_wait;
2246
2247 if (!this->select_chip)
2248 this->select_chip = nand_select_chip;
2249 if (!this->write_byte)
2250 this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
2251 if (!this->read_byte)
2252 this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
2253 if (!this->write_word)
2254 this->write_word = nand_write_word;
2255 if (!this->read_word)
2256 this->read_word = nand_read_word;
2257 if (!this->block_bad)
2258 this->block_bad = nand_block_bad;
2259 if (!this->block_markbad)
2260 this->block_markbad = nand_default_block_markbad;
2261 if (!this->write_buf)
2262 this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
2263 if (!this->read_buf)
2264 this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
2265 if (!this->verify_buf)
2266 this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
2267 if (!this->scan_bbt)
2268 this->scan_bbt = nand_default_bbt;
2269
2270 /* Select the device */
2271 this->select_chip(mtd, 0);
2272
2273 /* Send the command for reading device ID */
2274 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2275
2276 /* Read manufacturer and device IDs */
2277 nand_maf_id = this->read_byte(mtd);
2278 nand_dev_id = this->read_byte(mtd);
2279
2280 /* Print and store flash device information */
2281 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002282
2283 if (nand_dev_id != nand_flash_ids[i].id)
Wolfgang Denk932394a2005-08-17 12:55:25 +02002284 continue;
2285
2286 if (!mtd->name) mtd->name = nand_flash_ids[i].name;
2287 this->chipsize = nand_flash_ids[i].chipsize << 20;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002288
Wolfgang Denk932394a2005-08-17 12:55:25 +02002289 /* New devices have all the information in additional id bytes */
2290 if (!nand_flash_ids[i].pagesize) {
2291 int extid;
2292 /* The 3rd id byte contains non relevant data ATM */
2293 extid = this->read_byte(mtd);
2294 /* The 4th id byte is the important one */
2295 extid = this->read_byte(mtd);
2296 /* Calc pagesize */
2297 mtd->oobblock = 1024 << (extid & 0x3);
2298 extid >>= 2;
2299 /* Calc oobsize */
2300 mtd->oobsize = (8 << (extid & 0x03)) * (mtd->oobblock / 512);
2301 extid >>= 2;
2302 /* Calc blocksize. Blocksize is multiples of 64KiB */
2303 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2304 extid >>= 2;
2305 /* Get buswidth information */
2306 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002307
Wolfgang Denk932394a2005-08-17 12:55:25 +02002308 } else {
2309 /* Old devices have this data hardcoded in the
2310 * device id table */
2311 mtd->erasesize = nand_flash_ids[i].erasesize;
2312 mtd->oobblock = nand_flash_ids[i].pagesize;
2313 mtd->oobsize = mtd->oobblock / 32;
2314 busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16;
2315 }
2316
2317 /* Check, if buswidth is correct. Hardware drivers should set
2318 * this correct ! */
2319 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2320 printk (KERN_INFO "NAND device: Manufacturer ID:"
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002321 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
Wolfgang Denk932394a2005-08-17 12:55:25 +02002322 nand_manuf_ids[i].name , mtd->name);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002323 printk (KERN_WARNING
2324 "NAND bus width %d instead %d bit\n",
Wolfgang Denk932394a2005-08-17 12:55:25 +02002325 (this->options & NAND_BUSWIDTH_16) ? 16 : 8,
2326 busw ? 16 : 8);
2327 this->select_chip(mtd, -1);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002328 return 1;
Wolfgang Denk932394a2005-08-17 12:55:25 +02002329 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002330
2331 /* Calculate the address shift from the page size */
Wolfgang Denk932394a2005-08-17 12:55:25 +02002332 this->page_shift = ffs(mtd->oobblock) - 1;
2333 this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
2334 this->chip_shift = ffs(this->chipsize) - 1;
2335
2336 /* Set the bad block position */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002337 this->badblockpos = mtd->oobblock > 512 ?
Wolfgang Denk932394a2005-08-17 12:55:25 +02002338 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2339
2340 /* Get chip options, preserve non chip based options */
2341 this->options &= ~NAND_CHIPOPTIONS_MSK;
2342 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2343 /* Set this as a default. Board drivers can override it, if neccecary */
2344 this->options |= NAND_NO_AUTOINCR;
2345 /* Check if this is a not a samsung device. Do not clear the options
2346 * for chips which are not having an extended id.
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002347 */
Wolfgang Denk932394a2005-08-17 12:55:25 +02002348 if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
2349 this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002350
Wolfgang Denk932394a2005-08-17 12:55:25 +02002351 /* Check for AND chips with 4 page planes */
2352 if (this->options & NAND_4PAGE_ARRAY)
2353 this->erase_cmd = multi_erase_cmd;
2354 else
2355 this->erase_cmd = single_erase_cmd;
2356
2357 /* Do not replace user supplied command function ! */
2358 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2359 this->cmdfunc = nand_command_lp;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002360
Wolfgang Denk932394a2005-08-17 12:55:25 +02002361 /* Try to identify manufacturer */
2362 for (j = 0; nand_manuf_ids[j].id != 0x0; j++) {
2363 if (nand_manuf_ids[j].id == nand_maf_id)
2364 break;
2365 }
2366 printk (KERN_INFO "NAND device: Manufacturer ID:"
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002367 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
Wolfgang Denk932394a2005-08-17 12:55:25 +02002368 nand_manuf_ids[j].name , nand_flash_ids[i].name);
2369 break;
2370 }
2371
2372 if (!nand_flash_ids[i].name) {
2373 printk (KERN_WARNING "No NAND device found!!!\n");
2374 this->select_chip(mtd, -1);
2375 return 1;
2376 }
2377
2378 for (i=1; i < maxchips; i++) {
2379 this->select_chip(mtd, i);
2380
2381 /* Send the command for reading device ID */
2382 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
2383
2384 /* Read manufacturer and device IDs */
2385 if (nand_maf_id != this->read_byte(mtd) ||
2386 nand_dev_id != this->read_byte(mtd))
2387 break;
2388 }
2389 if (i > 1)
2390 printk(KERN_INFO "%d NAND chips detected\n", i);
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002391
Wolfgang Denk932394a2005-08-17 12:55:25 +02002392 /* Allocate buffers, if neccecary */
2393 if (!this->oob_buf) {
2394 size_t len;
2395 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
2396 this->oob_buf = kmalloc (len, GFP_KERNEL);
2397 if (!this->oob_buf) {
2398 printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
2399 return -ENOMEM;
2400 }
2401 this->options |= NAND_OOBBUF_ALLOC;
2402 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002403
Wolfgang Denk932394a2005-08-17 12:55:25 +02002404 if (!this->data_buf) {
2405 size_t len;
2406 len = mtd->oobblock + mtd->oobsize;
2407 this->data_buf = kmalloc (len, GFP_KERNEL);
2408 if (!this->data_buf) {
2409 if (this->options & NAND_OOBBUF_ALLOC)
2410 kfree (this->oob_buf);
2411 printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
2412 return -ENOMEM;
2413 }
2414 this->options |= NAND_DATABUF_ALLOC;
2415 }
2416
2417 /* Store the number of chips and calc total size for mtd */
2418 this->numchips = i;
2419 mtd->size = i * this->chipsize;
2420 /* Convert chipsize to number of pages per chip -1. */
2421 this->pagemask = (this->chipsize >> this->page_shift) - 1;
2422 /* Preset the internal oob buffer */
2423 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
2424
2425 /* If no default placement scheme is given, select an
2426 * appropriate one */
2427 if (!this->autooob) {
2428 /* Select the appropriate default oob placement scheme for
2429 * placement agnostic filesystems */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002430 switch (mtd->oobsize) {
Wolfgang Denk932394a2005-08-17 12:55:25 +02002431 case 8:
2432 this->autooob = &nand_oob_8;
2433 break;
2434 case 16:
2435 this->autooob = &nand_oob_16;
2436 break;
2437 case 64:
2438 this->autooob = &nand_oob_64;
2439 break;
2440 default:
2441 printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
2442 mtd->oobsize);
2443/* BUG(); */
2444 }
2445 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002446
Wolfgang Denk932394a2005-08-17 12:55:25 +02002447 /* The number of bytes available for the filesystem to place fs dependend
2448 * oob data */
2449 if (this->options & NAND_BUSWIDTH_16) {
2450 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 2);
2451 if (this->autooob->eccbytes & 0x01)
2452 mtd->oobavail--;
2453 } else
2454 mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 1);
2455
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002456 /*
Wolfgang Denk932394a2005-08-17 12:55:25 +02002457 * check ECC mode, default to software
2458 * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002459 * fallback to software ECC
Wolfgang Denk932394a2005-08-17 12:55:25 +02002460 */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002461 this->eccsize = 256; /* set default eccsize */
Wolfgang Denk932394a2005-08-17 12:55:25 +02002462 this->eccbytes = 3;
2463
2464 switch (this->eccmode) {
2465 case NAND_ECC_HW12_2048:
2466 if (mtd->oobblock < 2048) {
2467 printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
2468 mtd->oobblock);
2469 this->eccmode = NAND_ECC_SOFT;
2470 this->calculate_ecc = nand_calculate_ecc;
2471 this->correct_data = nand_correct_data;
2472 } else
2473 this->eccsize = 2048;
2474 break;
2475
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002476 case NAND_ECC_HW3_512:
2477 case NAND_ECC_HW6_512:
2478 case NAND_ECC_HW8_512:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002479 if (mtd->oobblock == 256) {
2480 printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
2481 this->eccmode = NAND_ECC_SOFT;
2482 this->calculate_ecc = nand_calculate_ecc;
2483 this->correct_data = nand_correct_data;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002484 } else
Wolfgang Denk932394a2005-08-17 12:55:25 +02002485 this->eccsize = 512; /* set eccsize to 512 */
2486 break;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002487
Wolfgang Denk932394a2005-08-17 12:55:25 +02002488 case NAND_ECC_HW3_256:
2489 break;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002490
2491 case NAND_ECC_NONE:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002492 printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
2493 this->eccmode = NAND_ECC_NONE;
2494 break;
2495
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002496 case NAND_ECC_SOFT:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002497 this->calculate_ecc = nand_calculate_ecc;
2498 this->correct_data = nand_correct_data;
2499 break;
2500
2501 default:
2502 printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
2503/* BUG(); */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002504 }
Wolfgang Denk932394a2005-08-17 12:55:25 +02002505
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002506 /* Check hardware ecc function availability and adjust number of ecc bytes per
Wolfgang Denk932394a2005-08-17 12:55:25 +02002507 * calculation step
2508 */
2509 switch (this->eccmode) {
2510 case NAND_ECC_HW12_2048:
2511 this->eccbytes += 4;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002512 case NAND_ECC_HW8_512:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002513 this->eccbytes += 2;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002514 case NAND_ECC_HW6_512:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002515 this->eccbytes += 3;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002516 case NAND_ECC_HW3_512:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002517 case NAND_ECC_HW3_256:
2518 if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
2519 break;
2520 printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
2521/* BUG(); */
2522 }
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002523
Wolfgang Denk932394a2005-08-17 12:55:25 +02002524 mtd->eccsize = this->eccsize;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002525
Wolfgang Denk932394a2005-08-17 12:55:25 +02002526 /* Set the number of read / write steps for one page to ensure ECC generation */
2527 switch (this->eccmode) {
2528 case NAND_ECC_HW12_2048:
2529 this->eccsteps = mtd->oobblock / 2048;
2530 break;
2531 case NAND_ECC_HW3_512:
2532 case NAND_ECC_HW6_512:
2533 case NAND_ECC_HW8_512:
2534 this->eccsteps = mtd->oobblock / 512;
2535 break;
2536 case NAND_ECC_HW3_256:
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002537 case NAND_ECC_SOFT:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002538 this->eccsteps = mtd->oobblock / 256;
2539 break;
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002540
2541 case NAND_ECC_NONE:
Wolfgang Denk932394a2005-08-17 12:55:25 +02002542 this->eccsteps = 1;
2543 break;
2544 }
2545
2546/* XXX U-BOOT XXX */
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002547#if 0
Wolfgang Denk932394a2005-08-17 12:55:25 +02002548 /* Initialize state, waitqueue and spinlock */
2549 this->state = FL_READY;
2550 init_waitqueue_head (&this->wq);
2551 spin_lock_init (&this->chip_lock);
2552#endif
2553
2554 /* De-select the device */
2555 this->select_chip(mtd, -1);
2556
2557 /* Invalidate the pagebuffer reference */
2558 this->pagebuf = -1;
2559
2560 /* Fill in remaining MTD driver data */
2561 mtd->type = MTD_NANDFLASH;
2562 mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
2563 mtd->ecctype = MTD_ECC_SW;
2564 mtd->erase = nand_erase;
2565 mtd->point = NULL;
2566 mtd->unpoint = NULL;
2567 mtd->read = nand_read;
2568 mtd->write = nand_write;
2569 mtd->read_ecc = nand_read_ecc;
2570 mtd->write_ecc = nand_write_ecc;
2571 mtd->read_oob = nand_read_oob;
2572 mtd->write_oob = nand_write_oob;
2573/* XXX U-BOOT XXX */
2574#if 0
2575 mtd->readv = NULL;
2576 mtd->writev = nand_writev;
2577 mtd->writev_ecc = nand_writev_ecc;
2578#endif
2579 mtd->sync = nand_sync;
2580/* XXX U-BOOT XXX */
2581#if 0
2582 mtd->lock = NULL;
2583 mtd->unlock = NULL;
2584 mtd->suspend = NULL;
2585 mtd->resume = NULL;
2586#endif
2587 mtd->block_isbad = nand_block_isbad;
2588 mtd->block_markbad = nand_block_markbad;
2589
2590 /* and make the autooob the default one */
2591 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2592/* XXX U-BOOT XXX */
2593#if 0
2594 mtd->owner = THIS_MODULE;
2595#endif
2596 /* Build bad block table */
2597 return this->scan_bbt (mtd);
2598}
2599
2600/**
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002601 * nand_release - [NAND Interface] Free resources held by the NAND device
Wolfgang Denk932394a2005-08-17 12:55:25 +02002602 * @mtd: MTD device structure
Wolfgang Denkac7eb8a32005-09-14 23:53:32 +02002603 */
Wolfgang Denk932394a2005-08-17 12:55:25 +02002604void nand_release (struct mtd_info *mtd)
2605{
2606 struct nand_chip *this = mtd->priv;
2607
2608#ifdef CONFIG_MTD_PARTITIONS
2609 /* Deregister partitions */
2610 del_mtd_partitions (mtd);
2611#endif
2612 /* Deregister the device */
2613/* XXX U-BOOT XXX */
2614#if 0
2615 del_mtd_device (mtd);
2616#endif
2617 /* Free bad block table memory, if allocated */
2618 if (this->bbt)
2619 kfree (this->bbt);
2620 /* Buffer allocated by nand_scan ? */
2621 if (this->options & NAND_OOBBUF_ALLOC)
2622 kfree (this->oob_buf);
2623 /* Buffer allocated by nand_scan ? */
2624 if (this->options & NAND_DATABUF_ALLOC)
2625 kfree (this->data_buf);
2626}
2627
2628#endif