aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mtd/nand/nand_base.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mtd/nand/nand_base.c')
-rw-r--r--drivers/mtd/nand/nand_base.c713
1 files changed, 354 insertions, 359 deletions
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 95e96fa1fceb..08dffb7a9389 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -69,6 +69,7 @@
69 * 69 *
70 */ 70 */
71 71
72#include <linux/module.h>
72#include <linux/delay.h> 73#include <linux/delay.h>
73#include <linux/errno.h> 74#include <linux/errno.h>
74#include <linux/sched.h> 75#include <linux/sched.h>
@@ -92,24 +93,24 @@ static struct nand_oobinfo nand_oob_8 = {
92 .useecc = MTD_NANDECC_AUTOPLACE, 93 .useecc = MTD_NANDECC_AUTOPLACE,
93 .eccbytes = 3, 94 .eccbytes = 3,
94 .eccpos = {0, 1, 2}, 95 .eccpos = {0, 1, 2},
95 .oobfree = { {3, 2}, {6, 2} } 96 .oobfree = {{3, 2}, {6, 2}}
96}; 97};
97 98
98static struct nand_oobinfo nand_oob_16 = { 99static struct nand_oobinfo nand_oob_16 = {
99 .useecc = MTD_NANDECC_AUTOPLACE, 100 .useecc = MTD_NANDECC_AUTOPLACE,
100 .eccbytes = 6, 101 .eccbytes = 6,
101 .eccpos = {0, 1, 2, 3, 6, 7}, 102 .eccpos = {0, 1, 2, 3, 6, 7},
102 .oobfree = { {8, 8} } 103 .oobfree = {{8, 8}}
103}; 104};
104 105
105static struct nand_oobinfo nand_oob_64 = { 106static struct nand_oobinfo nand_oob_64 = {
106 .useecc = MTD_NANDECC_AUTOPLACE, 107 .useecc = MTD_NANDECC_AUTOPLACE,
107 .eccbytes = 24, 108 .eccbytes = 24,
108 .eccpos = { 109 .eccpos = {
109 40, 41, 42, 43, 44, 45, 46, 47, 110 40, 41, 42, 43, 44, 45, 46, 47,
110 48, 49, 50, 51, 52, 53, 54, 55, 111 48, 49, 50, 51, 52, 53, 54, 55,
111 56, 57, 58, 59, 60, 61, 62, 63}, 112 56, 57, 58, 59, 60, 61, 62, 63},
112 .oobfree = { {2, 38} } 113 .oobfree = {{2, 38}}
113}; 114};
114 115
115/* This is used for padding purposes in nand_write_oob */ 116/* This is used for padding purposes in nand_write_oob */
@@ -131,32 +132,32 @@ static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len);
131static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len); 132static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len);
132static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len); 133static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len);
133 134
134static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf); 135static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
135static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, 136static int nand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
136 size_t * retlen, u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel); 137 size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
137static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf); 138static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
138static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf); 139static int nand_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
139static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len, 140static int nand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
140 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel); 141 size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel);
141static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char *buf); 142static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
142static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, 143static int nand_writev(struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);
143 unsigned long count, loff_t to, size_t * retlen); 144static int nand_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs,
144static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, 145 unsigned long count, loff_t to, size_t *retlen, u_char *eccbuf,
145 unsigned long count, loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel); 146 struct nand_oobinfo *oobsel);
146static int nand_erase (struct mtd_info *mtd, struct erase_info *instr); 147static int nand_erase(struct mtd_info *mtd, struct erase_info *instr);
147static void nand_sync (struct mtd_info *mtd); 148static void nand_sync(struct mtd_info *mtd);
148 149
149/* Some internal functions */ 150/* Some internal functions */
150static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, u_char *oob_buf, 151static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page, u_char * oob_buf,
151 struct nand_oobinfo *oobsel, int mode); 152 struct nand_oobinfo *oobsel, int mode);
152#ifdef CONFIG_MTD_NAND_VERIFY_WRITE 153#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
153static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages, 154static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
154 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode); 155 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode);
155#else 156#else
156#define nand_verify_pages(...) (0) 157#define nand_verify_pages(...) (0)
157#endif 158#endif
158 159
159static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state); 160static int nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state);
160 161
161/** 162/**
162 * nand_release_device - [GENERIC] release chip 163 * nand_release_device - [GENERIC] release chip
@@ -164,7 +165,7 @@ static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int ne
164 * 165 *
165 * Deselect, release chip lock and wake up anyone waiting on the device 166 * Deselect, release chip lock and wake up anyone waiting on the device
166 */ 167 */
167static void nand_release_device (struct mtd_info *mtd) 168static void nand_release_device(struct mtd_info *mtd)
168{ 169{
169 struct nand_chip *this = mtd->priv; 170 struct nand_chip *this = mtd->priv;
170 171
@@ -276,7 +277,7 @@ static void nand_write_word(struct mtd_info *mtd, u16 word)
276static void nand_select_chip(struct mtd_info *mtd, int chip) 277static void nand_select_chip(struct mtd_info *mtd, int chip)
277{ 278{
278 struct nand_chip *this = mtd->priv; 279 struct nand_chip *this = mtd->priv;
279 switch(chip) { 280 switch (chip) {
280 case -1: 281 case -1:
281 this->hwcontrol(mtd, NAND_CTL_CLRNCE); 282 this->hwcontrol(mtd, NAND_CTL_CLRNCE);
282 break; 283 break;
@@ -302,7 +303,7 @@ static void nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
302 int i; 303 int i;
303 struct nand_chip *this = mtd->priv; 304 struct nand_chip *this = mtd->priv;
304 305
305 for (i=0; i<len; i++) 306 for (i = 0; i < len; i++)
306 writeb(buf[i], this->IO_ADDR_W); 307 writeb(buf[i], this->IO_ADDR_W);
307} 308}
308 309
@@ -319,7 +320,7 @@ static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
319 int i; 320 int i;
320 struct nand_chip *this = mtd->priv; 321 struct nand_chip *this = mtd->priv;
321 322
322 for (i=0; i<len; i++) 323 for (i = 0; i < len; i++)
323 buf[i] = readb(this->IO_ADDR_R); 324 buf[i] = readb(this->IO_ADDR_R);
324} 325}
325 326
@@ -336,7 +337,7 @@ static int nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
336 int i; 337 int i;
337 struct nand_chip *this = mtd->priv; 338 struct nand_chip *this = mtd->priv;
338 339
339 for (i=0; i<len; i++) 340 for (i = 0; i < len; i++)
340 if (buf[i] != readb(this->IO_ADDR_R)) 341 if (buf[i] != readb(this->IO_ADDR_R))
341 return -EFAULT; 342 return -EFAULT;
342 343
@@ -358,7 +359,7 @@ static void nand_write_buf16(struct mtd_info *mtd, const u_char *buf, int len)
358 u16 *p = (u16 *) buf; 359 u16 *p = (u16 *) buf;
359 len >>= 1; 360 len >>= 1;
360 361
361 for (i=0; i<len; i++) 362 for (i = 0; i < len; i++)
362 writew(p[i], this->IO_ADDR_W); 363 writew(p[i], this->IO_ADDR_W);
363 364
364} 365}
@@ -378,7 +379,7 @@ static void nand_read_buf16(struct mtd_info *mtd, u_char *buf, int len)
378 u16 *p = (u16 *) buf; 379 u16 *p = (u16 *) buf;
379 len >>= 1; 380 len >>= 1;
380 381
381 for (i=0; i<len; i++) 382 for (i = 0; i < len; i++)
382 p[i] = readw(this->IO_ADDR_R); 383 p[i] = readw(this->IO_ADDR_R);
383} 384}
384 385
@@ -397,7 +398,7 @@ static int nand_verify_buf16(struct mtd_info *mtd, const u_char *buf, int len)
397 u16 *p = (u16 *) buf; 398 u16 *p = (u16 *) buf;
398 len >>= 1; 399 len >>= 1;
399 400
400 for (i=0; i<len; i++) 401 for (i = 0; i < len; i++)
401 if (p[i] != readw(this->IO_ADDR_R)) 402 if (p[i] != readw(this->IO_ADDR_R))
402 return -EFAULT; 403 return -EFAULT;
403 404
@@ -423,22 +424,22 @@ static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
423 chipnr = (int)(ofs >> this->chip_shift); 424 chipnr = (int)(ofs >> this->chip_shift);
424 425
425 /* Grab the lock and see if the device is available */ 426 /* Grab the lock and see if the device is available */
426 nand_get_device (this, mtd, FL_READING); 427 nand_get_device(this, mtd, FL_READING);
427 428
428 /* Select the NAND device */ 429 /* Select the NAND device */
429 this->select_chip(mtd, chipnr); 430 this->select_chip(mtd, chipnr);
430 } else 431 } else
431 page = (int) ofs; 432 page = (int)ofs;
432 433
433 if (this->options & NAND_BUSWIDTH_16) { 434 if (this->options & NAND_BUSWIDTH_16) {
434 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask); 435 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page & this->pagemask);
435 bad = cpu_to_le16(this->read_word(mtd)); 436 bad = cpu_to_le16(this->read_word(mtd));
436 if (this->badblockpos & 0x1) 437 if (this->badblockpos & 0x1)
437 bad >>= 8; 438 bad >>= 8;
438 if ((bad & 0xFF) != 0xff) 439 if ((bad & 0xFF) != 0xff)
439 res = 1; 440 res = 1;
440 } else { 441 } else {
441 this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask); 442 this->cmdfunc(mtd, NAND_CMD_READOOB, this->badblockpos, page & this->pagemask);
442 if (this->read_byte(mtd) != 0xff) 443 if (this->read_byte(mtd) != 0xff)
443 res = 1; 444 res = 1;
444 } 445 }
@@ -462,22 +463,22 @@ static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
462static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs) 463static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
463{ 464{
464 struct nand_chip *this = mtd->priv; 465 struct nand_chip *this = mtd->priv;
465 u_char buf[2] = {0, 0}; 466 u_char buf[2] = { 0, 0 };
466 size_t retlen; 467 size_t retlen;
467 int block; 468 int block;
468 469
469 /* Get block number */ 470 /* Get block number */
470 block = ((int) ofs) >> this->bbt_erase_shift; 471 block = ((int)ofs) >> this->bbt_erase_shift;
471 if (this->bbt) 472 if (this->bbt)
472 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1); 473 this->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
473 474
474 /* Do we have a flash based bad block table ? */ 475 /* Do we have a flash based bad block table ? */
475 if (this->options & NAND_USE_FLASH_BBT) 476 if (this->options & NAND_USE_FLASH_BBT)
476 return nand_update_bbt (mtd, ofs); 477 return nand_update_bbt(mtd, ofs);
477 478
478 /* We write two bytes, so we dont have to mess with 16 bit access */ 479 /* We write two bytes, so we dont have to mess with 16 bit access */
479 ofs += mtd->oobsize + (this->badblockpos & ~0x01); 480 ofs += mtd->oobsize + (this->badblockpos & ~0x01);
480 return nand_write_oob (mtd, ofs , 2, &retlen, buf); 481 return nand_write_oob(mtd, ofs, 2, &retlen, buf);
481} 482}
482 483
483/** 484/**
@@ -487,11 +488,11 @@ static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
487 * 488 *
488 * The function expects, that the device is already selected 489 * The function expects, that the device is already selected
489 */ 490 */
490static int nand_check_wp (struct mtd_info *mtd) 491static int nand_check_wp(struct mtd_info *mtd)
491{ 492{
492 struct nand_chip *this = mtd->priv; 493 struct nand_chip *this = mtd->priv;
493 /* Check the WP bit */ 494 /* Check the WP bit */
494 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1); 495 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
495 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1; 496 return (this->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
496} 497}
497 498
@@ -505,7 +506,7 @@ static int nand_check_wp (struct mtd_info *mtd)
505 * Check, if the block is bad. Either by reading the bad block table or 506 * Check, if the block is bad. Either by reading the bad block table or
506 * calling of the scan function. 507 * calling of the scan function.
507 */ 508 */
508static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt) 509static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
509{ 510{
510 struct nand_chip *this = mtd->priv; 511 struct nand_chip *this = mtd->priv;
511 512
@@ -513,7 +514,7 @@ static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, i
513 return this->block_bad(mtd, ofs, getchip); 514 return this->block_bad(mtd, ofs, getchip);
514 515
515 /* Return info from the table */ 516 /* Return info from the table */
516 return nand_isbad_bbt (mtd, ofs, allowbbt); 517 return nand_isbad_bbt(mtd, ofs, allowbbt);
517} 518}
518 519
519DEFINE_LED_TRIGGER(nand_led_trigger); 520DEFINE_LED_TRIGGER(nand_led_trigger);
@@ -525,7 +526,7 @@ DEFINE_LED_TRIGGER(nand_led_trigger);
525static void nand_wait_ready(struct mtd_info *mtd) 526static void nand_wait_ready(struct mtd_info *mtd)
526{ 527{
527 struct nand_chip *this = mtd->priv; 528 struct nand_chip *this = mtd->priv;
528 unsigned long timeo = jiffies + 2; 529 unsigned long timeo = jiffies + 2;
529 530
530 led_trigger_event(nand_led_trigger, LED_FULL); 531 led_trigger_event(nand_led_trigger, LED_FULL);
531 /* wait until command is processed or timeout occures */ 532 /* wait until command is processed or timeout occures */
@@ -547,7 +548,7 @@ static void nand_wait_ready(struct mtd_info *mtd)
547 * Send command to NAND device. This function is used for small page 548 * Send command to NAND device. This function is used for small page
548 * devices (256/512 Bytes per page) 549 * devices (256/512 Bytes per page)
549 */ 550 */
550static void nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr) 551static void nand_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
551{ 552{
552 register struct nand_chip *this = mtd->priv; 553 register struct nand_chip *this = mtd->priv;
553 554
@@ -588,11 +589,11 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
588 this->write_byte(mtd, column); 589 this->write_byte(mtd, column);
589 } 590 }
590 if (page_addr != -1) { 591 if (page_addr != -1) {
591 this->write_byte(mtd, (unsigned char) (page_addr & 0xff)); 592 this->write_byte(mtd, (unsigned char)(page_addr & 0xff));
592 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff)); 593 this->write_byte(mtd, (unsigned char)((page_addr >> 8) & 0xff));
593 /* One more address cycle for devices > 32MiB */ 594 /* One more address cycle for devices > 32MiB */
594 if (this->chipsize > (32 << 20)) 595 if (this->chipsize > (32 << 20))
595 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0x0f)); 596 this->write_byte(mtd, (unsigned char)((page_addr >> 16) & 0x0f));
596 } 597 }
597 /* Latch in address */ 598 /* Latch in address */
598 this->hwcontrol(mtd, NAND_CTL_CLRALE); 599 this->hwcontrol(mtd, NAND_CTL_CLRALE);
@@ -601,7 +602,7 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
601 /* 602 /*
602 * program and erase have their own busy handlers 603 * program and erase have their own busy handlers
603 * status and sequential in needs no delay 604 * status and sequential in needs no delay
604 */ 605 */
605 switch (command) { 606 switch (command) {
606 607
607 case NAND_CMD_PAGEPROG: 608 case NAND_CMD_PAGEPROG:
@@ -618,23 +619,23 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
618 this->hwcontrol(mtd, NAND_CTL_SETCLE); 619 this->hwcontrol(mtd, NAND_CTL_SETCLE);
619 this->write_byte(mtd, NAND_CMD_STATUS); 620 this->write_byte(mtd, NAND_CMD_STATUS);
620 this->hwcontrol(mtd, NAND_CTL_CLRCLE); 621 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
621 while ( !(this->read_byte(mtd) & NAND_STATUS_READY)); 622 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
622 return; 623 return;
623 624
624 /* This applies to read commands */ 625 /* This applies to read commands */
625 default: 626 default:
626 /* 627 /*
627 * If we don't have access to the busy pin, we apply the given 628 * If we don't have access to the busy pin, we apply the given
628 * command delay 629 * command delay
629 */ 630 */
630 if (!this->dev_ready) { 631 if (!this->dev_ready) {
631 udelay (this->chip_delay); 632 udelay(this->chip_delay);
632 return; 633 return;
633 } 634 }
634 } 635 }
635 /* Apply this short delay always to ensure that we do wait tWB in 636 /* Apply this short delay always to ensure that we do wait tWB in
636 * any case on any machine. */ 637 * any case on any machine. */
637 ndelay (100); 638 ndelay(100);
638 639
639 nand_wait_ready(mtd); 640 nand_wait_ready(mtd);
640} 641}
@@ -647,11 +648,11 @@ static void nand_command (struct mtd_info *mtd, unsigned command, int column, in
647 * @page_addr: the page address for this command, -1 if none 648 * @page_addr: the page address for this command, -1 if none
648 * 649 *
649 * Send command to NAND device. This is the version for the new large page devices 650 * Send command to NAND device. This is the version for the new large page devices
650 * We dont have the seperate regions as we have in the small page devices. 651 * We dont have the separate regions as we have in the small page devices.
651 * We must emulate NAND_CMD_READOOB to keep the code compatible. 652 * We must emulate NAND_CMD_READOOB to keep the code compatible.
652 * 653 *
653 */ 654 */
654static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column, int page_addr) 655static void nand_command_lp(struct mtd_info *mtd, unsigned command, int column, int page_addr)
655{ 656{
656 register struct nand_chip *this = mtd->priv; 657 register struct nand_chip *this = mtd->priv;
657 658
@@ -661,7 +662,6 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
661 command = NAND_CMD_READ0; 662 command = NAND_CMD_READ0;
662 } 663 }
663 664
664
665 /* Begin command latch cycle */ 665 /* Begin command latch cycle */
666 this->hwcontrol(mtd, NAND_CTL_SETCLE); 666 this->hwcontrol(mtd, NAND_CTL_SETCLE);
667 /* Write out the command to the device. */ 667 /* Write out the command to the device. */
@@ -681,11 +681,11 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
681 this->write_byte(mtd, column >> 8); 681 this->write_byte(mtd, column >> 8);
682 } 682 }
683 if (page_addr != -1) { 683 if (page_addr != -1) {
684 this->write_byte(mtd, (unsigned char) (page_addr & 0xff)); 684 this->write_byte(mtd, (unsigned char)(page_addr & 0xff));
685 this->write_byte(mtd, (unsigned char) ((page_addr >> 8) & 0xff)); 685 this->write_byte(mtd, (unsigned char)((page_addr >> 8) & 0xff));
686 /* One more address cycle for devices > 128MiB */ 686 /* One more address cycle for devices > 128MiB */
687 if (this->chipsize > (128 << 20)) 687 if (this->chipsize > (128 << 20))
688 this->write_byte(mtd, (unsigned char) ((page_addr >> 16) & 0xff)); 688 this->write_byte(mtd, (unsigned char)((page_addr >> 16) & 0xff));
689 } 689 }
690 /* Latch in address */ 690 /* Latch in address */
691 this->hwcontrol(mtd, NAND_CTL_CLRALE); 691 this->hwcontrol(mtd, NAND_CTL_CLRALE);
@@ -706,9 +706,9 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
706 case NAND_CMD_DEPLETE1: 706 case NAND_CMD_DEPLETE1:
707 return; 707 return;
708 708
709 /* 709 /*
710 * read error status commands require only a short delay 710 * read error status commands require only a short delay
711 */ 711 */
712 case NAND_CMD_STATUS_ERROR: 712 case NAND_CMD_STATUS_ERROR:
713 case NAND_CMD_STATUS_ERROR0: 713 case NAND_CMD_STATUS_ERROR0:
714 case NAND_CMD_STATUS_ERROR1: 714 case NAND_CMD_STATUS_ERROR1:
@@ -724,7 +724,7 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
724 this->hwcontrol(mtd, NAND_CTL_SETCLE); 724 this->hwcontrol(mtd, NAND_CTL_SETCLE);
725 this->write_byte(mtd, NAND_CMD_STATUS); 725 this->write_byte(mtd, NAND_CMD_STATUS);
726 this->hwcontrol(mtd, NAND_CTL_CLRCLE); 726 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
727 while ( !(this->read_byte(mtd) & NAND_STATUS_READY)); 727 while (!(this->read_byte(mtd) & NAND_STATUS_READY)) ;
728 return; 728 return;
729 729
730 case NAND_CMD_READ0: 730 case NAND_CMD_READ0:
@@ -736,21 +736,21 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
736 this->hwcontrol(mtd, NAND_CTL_CLRCLE); 736 this->hwcontrol(mtd, NAND_CTL_CLRCLE);
737 /* Fall through into ready check */ 737 /* Fall through into ready check */
738 738
739 /* This applies to read commands */ 739 /* This applies to read commands */
740 default: 740 default:
741 /* 741 /*
742 * If we don't have access to the busy pin, we apply the given 742 * If we don't have access to the busy pin, we apply the given
743 * command delay 743 * command delay
744 */ 744 */
745 if (!this->dev_ready) { 745 if (!this->dev_ready) {
746 udelay (this->chip_delay); 746 udelay(this->chip_delay);
747 return; 747 return;
748 } 748 }
749 } 749 }
750 750
751 /* Apply this short delay always to ensure that we do wait tWB in 751 /* Apply this short delay always to ensure that we do wait tWB in
752 * any case on any machine. */ 752 * any case on any machine. */
753 ndelay (100); 753 ndelay(100);
754 754
755 nand_wait_ready(mtd); 755 nand_wait_ready(mtd);
756} 756}
@@ -763,16 +763,16 @@ static void nand_command_lp (struct mtd_info *mtd, unsigned command, int column,
763 * 763 *
764 * Get the device and lock it for exclusive access 764 * Get the device and lock it for exclusive access
765 */ 765 */
766static int nand_get_device (struct nand_chip *this, struct mtd_info *mtd, int new_state) 766static int nand_get_device(struct nand_chip *this, struct mtd_info *mtd, int new_state)
767{ 767{
768 struct nand_chip *active; 768 struct nand_chip *active;
769 spinlock_t *lock; 769 spinlock_t *lock;
770 wait_queue_head_t *wq; 770 wait_queue_head_t *wq;
771 DECLARE_WAITQUEUE (wait, current); 771 DECLARE_WAITQUEUE(wait, current);
772 772
773 lock = (this->controller) ? &this->controller->lock : &this->chip_lock; 773 lock = (this->controller) ? &this->controller->lock : &this->chip_lock;
774 wq = (this->controller) ? &this->controller->wq : &this->wq; 774 wq = (this->controller) ? &this->controller->wq : &this->wq;
775retry: 775 retry:
776 active = this; 776 active = this;
777 spin_lock(lock); 777 spin_lock(lock);
778 778
@@ -814,24 +814,24 @@ retry:
814static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state) 814static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
815{ 815{
816 816
817 unsigned long timeo = jiffies; 817 unsigned long timeo = jiffies;
818 int status; 818 int status;
819 819
820 if (state == FL_ERASING) 820 if (state == FL_ERASING)
821 timeo += (HZ * 400) / 1000; 821 timeo += (HZ * 400) / 1000;
822 else 822 else
823 timeo += (HZ * 20) / 1000; 823 timeo += (HZ * 20) / 1000;
824 824
825 led_trigger_event(nand_led_trigger, LED_FULL); 825 led_trigger_event(nand_led_trigger, LED_FULL);
826 826
827 /* Apply this short delay always to ensure that we do wait tWB in 827 /* Apply this short delay always to ensure that we do wait tWB in
828 * any case on any machine. */ 828 * any case on any machine. */
829 ndelay (100); 829 ndelay(100);
830 830
831 if ((state == FL_ERASING) && (this->options & NAND_IS_AND)) 831 if ((state == FL_ERASING) && (this->options & NAND_IS_AND))
832 this->cmdfunc (mtd, NAND_CMD_STATUS_MULTI, -1, -1); 832 this->cmdfunc(mtd, NAND_CMD_STATUS_MULTI, -1, -1);
833 else 833 else
834 this->cmdfunc (mtd, NAND_CMD_STATUS, -1, -1); 834 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
835 835
836 while (time_before(jiffies, timeo)) { 836 while (time_before(jiffies, timeo)) {
837 /* Check, if we were interrupted */ 837 /* Check, if we were interrupted */
@@ -849,7 +849,7 @@ static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
849 } 849 }
850 led_trigger_event(nand_led_trigger, LED_OFF); 850 led_trigger_event(nand_led_trigger, LED_OFF);
851 851
852 status = (int) this->read_byte(mtd); 852 status = (int)this->read_byte(mtd);
853 return status; 853 return status;
854} 854}
855 855
@@ -868,31 +868,31 @@ static int nand_wait(struct mtd_info *mtd, struct nand_chip *this, int state)
868 * 868 *
869 * Cached programming is not supported yet. 869 * Cached programming is not supported yet.
870 */ 870 */
871static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int page, 871static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this, int page,
872 u_char *oob_buf, struct nand_oobinfo *oobsel, int cached) 872 u_char *oob_buf, struct nand_oobinfo *oobsel, int cached)
873{ 873{
874 int i, status; 874 int i, status;
875 u_char ecc_code[32]; 875 u_char ecc_code[32];
876 int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE; 876 int eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
877 int *oob_config = oobsel->eccpos; 877 int *oob_config = oobsel->eccpos;
878 int datidx = 0, eccidx = 0, eccsteps = this->eccsteps; 878 int datidx = 0, eccidx = 0, eccsteps = this->eccsteps;
879 int eccbytes = 0; 879 int eccbytes = 0;
880 880
881 /* FIXME: Enable cached programming */ 881 /* FIXME: Enable cached programming */
882 cached = 0; 882 cached = 0;
883 883
884 /* Send command to begin auto page programming */ 884 /* Send command to begin auto page programming */
885 this->cmdfunc (mtd, NAND_CMD_SEQIN, 0x00, page); 885 this->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
886 886
887 /* Write out complete page of data, take care of eccmode */ 887 /* Write out complete page of data, take care of eccmode */
888 switch (eccmode) { 888 switch (eccmode) {
889 /* No ecc, write all */ 889 /* No ecc, write all */
890 case NAND_ECC_NONE: 890 case NAND_ECC_NONE:
891 printk (KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n"); 891 printk(KERN_WARNING "Writing data without ECC to NAND-FLASH is not recommended\n");
892 this->write_buf(mtd, this->data_poi, mtd->oobblock); 892 this->write_buf(mtd, this->data_poi, mtd->oobblock);
893 break; 893 break;
894 894
895 /* Software ecc 3/256, write all */ 895 /* Software ecc 3/256, write all */
896 case NAND_ECC_SOFT: 896 case NAND_ECC_SOFT:
897 for (; eccsteps; eccsteps--) { 897 for (; eccsteps; eccsteps--) {
898 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code); 898 this->calculate_ecc(mtd, &this->data_poi[datidx], ecc_code);
@@ -928,11 +928,11 @@ static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int pa
928 this->write_buf(mtd, oob_buf, mtd->oobsize); 928 this->write_buf(mtd, oob_buf, mtd->oobsize);
929 929
930 /* Send command to actually program the data */ 930 /* Send command to actually program the data */
931 this->cmdfunc (mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1); 931 this->cmdfunc(mtd, cached ? NAND_CMD_CACHEDPROG : NAND_CMD_PAGEPROG, -1, -1);
932 932
933 if (!cached) { 933 if (!cached) {
934 /* call wait ready function */ 934 /* call wait ready function */
935 status = this->waitfunc (mtd, this, FL_WRITING); 935 status = this->waitfunc(mtd, this, FL_WRITING);
936 936
937 /* See if operation failed and additional status checks are available */ 937 /* See if operation failed and additional status checks are available */
938 if ((status & NAND_STATUS_FAIL) && (this->errstat)) { 938 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
@@ -941,12 +941,12 @@ static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int pa
941 941
942 /* See if device thinks it succeeded */ 942 /* See if device thinks it succeeded */
943 if (status & NAND_STATUS_FAIL) { 943 if (status & NAND_STATUS_FAIL) {
944 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page); 944 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write, page 0x%08x, ", __FUNCTION__, page);
945 return -EIO; 945 return -EIO;
946 } 946 }
947 } else { 947 } else {
948 /* FIXME: Implement cached programming ! */ 948 /* FIXME: Implement cached programming ! */
949 /* wait until cache is ready*/ 949 /* wait until cache is ready */
950 // status = this->waitfunc (mtd, this, FL_CACHEDRPG); 950 // status = this->waitfunc (mtd, this, FL_CACHEDRPG);
951 } 951 }
952 return 0; 952 return 0;
@@ -972,24 +972,24 @@ static int nand_write_page (struct mtd_info *mtd, struct nand_chip *this, int pa
972 * the error later when the ECC page check fails, but we would rather catch 972 * the error later when the ECC page check fails, but we would rather catch
973 * it early in the page write stage. Better to write no data than invalid data. 973 * it early in the page write stage. Better to write no data than invalid data.
974 */ 974 */
975static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int page, int numpages, 975static int nand_verify_pages(struct mtd_info *mtd, struct nand_chip *this, int page, int numpages,
976 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode) 976 u_char *oob_buf, struct nand_oobinfo *oobsel, int chipnr, int oobmode)
977{ 977{
978 int i, j, datidx = 0, oobofs = 0, res = -EIO; 978 int i, j, datidx = 0, oobofs = 0, res = -EIO;
979 int eccsteps = this->eccsteps; 979 int eccsteps = this->eccsteps;
980 int hweccbytes; 980 int hweccbytes;
981 u_char oobdata[64]; 981 u_char oobdata[64];
982 982
983 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0; 983 hweccbytes = (this->options & NAND_HWECC_SYNDROME) ? (oobsel->eccbytes / eccsteps) : 0;
984 984
985 /* Send command to read back the first page */ 985 /* Send command to read back the first page */
986 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page); 986 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
987 987
988 for(;;) { 988 for (;;) {
989 for (j = 0; j < eccsteps; j++) { 989 for (j = 0; j < eccsteps; j++) {
990 /* Loop through and verify the data */ 990 /* Loop through and verify the data */
991 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) { 991 if (this->verify_buf(mtd, &this->data_poi[datidx], mtd->eccsize)) {
992 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page); 992 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
993 goto out; 993 goto out;
994 } 994 }
995 datidx += mtd->eccsize; 995 datidx += mtd->eccsize;
@@ -997,7 +997,7 @@ static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int
997 if (!hweccbytes) 997 if (!hweccbytes)
998 continue; 998 continue;
999 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) { 999 if (this->verify_buf(mtd, &this->oob_buf[oobofs], hweccbytes)) {
1000 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page); 1000 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1001 goto out; 1001 goto out;
1002 } 1002 }
1003 oobofs += hweccbytes; 1003 oobofs += hweccbytes;
@@ -1008,7 +1008,7 @@ static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int
1008 */ 1008 */
1009 if (oobmode) { 1009 if (oobmode) {
1010 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) { 1010 if (this->verify_buf(mtd, &oob_buf[oobofs], mtd->oobsize - hweccbytes * eccsteps)) {
1011 DEBUG (MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page); 1011 DEBUG(MTD_DEBUG_LEVEL0, "%s: " "Failed write verify, page 0x%08x ", __FUNCTION__, page);
1012 goto out; 1012 goto out;
1013 } 1013 }
1014 } else { 1014 } else {
@@ -1020,10 +1020,9 @@ static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int
1020 1020
1021 for (i = 0; i < ecccnt; i++) { 1021 for (i = 0; i < ecccnt; i++) {
1022 int idx = oobsel->eccpos[i]; 1022 int idx = oobsel->eccpos[i];
1023 if (oobdata[idx] != oob_buf[oobofs + idx] ) { 1023 if (oobdata[idx] != oob_buf[oobofs + idx]) {
1024 DEBUG (MTD_DEBUG_LEVEL0, 1024 DEBUG(MTD_DEBUG_LEVEL0, "%s: Failed ECC write verify, page 0x%08x, %6i bytes were succesful\n",
1025 "%s: Failed ECC write " 1025 __FUNCTION__, page, i);
1026 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
1027 goto out; 1026 goto out;
1028 } 1027 }
1029 } 1028 }
@@ -1039,9 +1038,9 @@ static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int
1039 * is marked as NOAUTOINCR by the board driver. 1038 * is marked as NOAUTOINCR by the board driver.
1040 * Do this also before returning, so the chip is 1039 * Do this also before returning, so the chip is
1041 * ready for the next command. 1040 * ready for the next command.
1042 */ 1041 */
1043 if (!this->dev_ready) 1042 if (!this->dev_ready)
1044 udelay (this->chip_delay); 1043 udelay(this->chip_delay);
1045 else 1044 else
1046 nand_wait_ready(mtd); 1045 nand_wait_ready(mtd);
1047 1046
@@ -1049,17 +1048,16 @@ static int nand_verify_pages (struct mtd_info *mtd, struct nand_chip *this, int
1049 if (!numpages) 1048 if (!numpages)
1050 return 0; 1049 return 0;
1051 1050
1052
1053 /* Check, if the chip supports auto page increment */ 1051 /* Check, if the chip supports auto page increment */
1054 if (!NAND_CANAUTOINCR(this)) 1052 if (!NAND_CANAUTOINCR(this))
1055 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page); 1053 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1056 } 1054 }
1057 /* 1055 /*
1058 * Terminate the read command. We come here in case of an error 1056 * Terminate the read command. We come here in case of an error
1059 * So we must issue a reset command. 1057 * So we must issue a reset command.
1060 */ 1058 */
1061out: 1059 out:
1062 this->cmdfunc (mtd, NAND_CMD_RESET, -1, -1); 1060 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1063 return res; 1061 return res;
1064} 1062}
1065#endif 1063#endif
@@ -1075,12 +1073,11 @@ out:
1075 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL 1073 * This function simply calls nand_do_read_ecc with oob buffer and oobsel = NULL
1076 * and flags = 0xff 1074 * and flags = 0xff
1077 */ 1075 */
1078static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf) 1076static int nand_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1079{ 1077{
1080 return nand_do_read_ecc (mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff); 1078 return nand_do_read_ecc(mtd, from, len, retlen, buf, NULL, &mtd->oobinfo, 0xff);
1081} 1079}
1082 1080
1083
1084/** 1081/**
1085 * nand_read_ecc - [MTD Interface] MTD compability function for nand_do_read_ecc 1082 * nand_read_ecc - [MTD Interface] MTD compability function for nand_do_read_ecc
1086 * @mtd: MTD device structure 1083 * @mtd: MTD device structure
@@ -1093,8 +1090,8 @@ static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * re
1093 * 1090 *
1094 * This function simply calls nand_do_read_ecc with flags = 0xff 1091 * This function simply calls nand_do_read_ecc with flags = 0xff
1095 */ 1092 */
1096static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, 1093static int nand_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1097 size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel) 1094 size_t *retlen, u_char *buf, u_char *oob_buf, struct nand_oobinfo *oobsel)
1098{ 1095{
1099 /* use userspace supplied oobinfo, if zero */ 1096 /* use userspace supplied oobinfo, if zero */
1100 if (oobsel == NULL) 1097 if (oobsel == NULL)
@@ -1102,7 +1099,6 @@ static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1102 return nand_do_read_ecc(mtd, from, len, retlen, buf, oob_buf, oobsel, 0xff); 1099 return nand_do_read_ecc(mtd, from, len, retlen, buf, oob_buf, oobsel, 0xff);
1103} 1100}
1104 1101
1105
1106/** 1102/**
1107 * nand_do_read_ecc - [MTD Interface] Read data with ECC 1103 * nand_do_read_ecc - [MTD Interface] Read data with ECC
1108 * @mtd: MTD device structure 1104 * @mtd: MTD device structure
@@ -1119,9 +1115,8 @@ static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1119 * 1115 *
1120 * NAND read with ECC 1116 * NAND read with ECC
1121 */ 1117 */
1122int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, 1118int nand_do_read_ecc(struct mtd_info *mtd, loff_t from, size_t len,
1123 size_t * retlen, u_char * buf, u_char * oob_buf, 1119 size_t *retlen, u_char *buf, u_char *oob_buf, struct nand_oobinfo *oobsel, int flags)
1124 struct nand_oobinfo *oobsel, int flags)
1125{ 1120{
1126 1121
1127 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1; 1122 int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
@@ -1130,26 +1125,25 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1130 u_char *data_poi, *oob_data = oob_buf; 1125 u_char *data_poi, *oob_data = oob_buf;
1131 u_char ecc_calc[32]; 1126 u_char ecc_calc[32];
1132 u_char ecc_code[32]; 1127 u_char ecc_code[32];
1133 int eccmode, eccsteps; 1128 int eccmode, eccsteps;
1134 int *oob_config, datidx; 1129 int *oob_config, datidx;
1135 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1; 1130 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1136 int eccbytes; 1131 int eccbytes;
1137 int compareecc = 1; 1132 int compareecc = 1;
1138 int oobreadlen; 1133 int oobreadlen;
1139 1134
1140 1135 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1141 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
1142 1136
1143 /* Do not allow reads past end of device */ 1137 /* Do not allow reads past end of device */
1144 if ((from + len) > mtd->size) { 1138 if ((from + len) > mtd->size) {
1145 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n"); 1139 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
1146 *retlen = 0; 1140 *retlen = 0;
1147 return -EINVAL; 1141 return -EINVAL;
1148 } 1142 }
1149 1143
1150 /* Grab the lock and see if the device is available */ 1144 /* Grab the lock and see if the device is available */
1151 if (flags & NAND_GET_DEVICE) 1145 if (flags & NAND_GET_DEVICE)
1152 nand_get_device (this, mtd, FL_READING); 1146 nand_get_device(this, mtd, FL_READING);
1153 1147
1154 /* Autoplace of oob data ? Use the default placement scheme */ 1148 /* Autoplace of oob data ? Use the default placement scheme */
1155 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE) 1149 if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
@@ -1163,7 +1157,7 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1163 this->select_chip(mtd, chipnr); 1157 this->select_chip(mtd, chipnr);
1164 1158
1165 /* First we calculate the starting page */ 1159 /* First we calculate the starting page */
1166 realpage = (int) (from >> this->page_shift); 1160 realpage = (int)(from >> this->page_shift);
1167 page = realpage & this->pagemask; 1161 page = realpage & this->pagemask;
1168 1162
1169 /* Get raw starting column */ 1163 /* Get raw starting column */
@@ -1201,13 +1195,13 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1201 if (realpage == this->pagebuf && !oob_buf) { 1195 if (realpage == this->pagebuf && !oob_buf) {
1202 /* aligned read ? */ 1196 /* aligned read ? */
1203 if (aligned) 1197 if (aligned)
1204 memcpy (data_poi, this->data_buf, end); 1198 memcpy(data_poi, this->data_buf, end);
1205 goto readdata; 1199 goto readdata;
1206 } 1200 }
1207 1201
1208 /* Check, if we must send the read command */ 1202 /* Check, if we must send the read command */
1209 if (sndcmd) { 1203 if (sndcmd) {
1210 this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page); 1204 this->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
1211 sndcmd = 0; 1205 sndcmd = 0;
1212 } 1206 }
1213 1207
@@ -1219,24 +1213,26 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1219 eccsteps = this->eccsteps; 1213 eccsteps = this->eccsteps;
1220 1214
1221 switch (eccmode) { 1215 switch (eccmode) {
1222 case NAND_ECC_NONE: { /* No ECC, Read in a page */ 1216 case NAND_ECC_NONE:{
1223 static unsigned long lastwhinge = 0; 1217 /* No ECC, Read in a page */
1224 if ((lastwhinge / HZ) != (jiffies / HZ)) { 1218 static unsigned long lastwhinge = 0;
1225 printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n"); 1219 if ((lastwhinge / HZ) != (jiffies / HZ)) {
1226 lastwhinge = jiffies; 1220 printk(KERN_WARNING
1221 "Reading data from NAND FLASH without ECC is not recommended\n");
1222 lastwhinge = jiffies;
1223 }
1224 this->read_buf(mtd, data_poi, end);
1225 break;
1227 } 1226 }
1228 this->read_buf(mtd, data_poi, end);
1229 break;
1230 }
1231 1227
1232 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */ 1228 case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
1233 this->read_buf(mtd, data_poi, end); 1229 this->read_buf(mtd, data_poi, end);
1234 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc) 1230 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += 3, datidx += ecc)
1235 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]); 1231 this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
1236 break; 1232 break;
1237 1233
1238 default: 1234 default:
1239 for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) { 1235 for (i = 0, datidx = 0; eccsteps; eccsteps--, i += eccbytes, datidx += ecc) {
1240 this->enable_hwecc(mtd, NAND_ECC_READ); 1236 this->enable_hwecc(mtd, NAND_ECC_READ);
1241 this->read_buf(mtd, &data_poi[datidx], ecc); 1237 this->read_buf(mtd, &data_poi[datidx], ecc);
1242 1238
@@ -1252,8 +1248,8 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1252 * does the error correction on the fly */ 1248 * does the error correction on the fly */
1253 ecc_status = this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]); 1249 ecc_status = this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]);
1254 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) { 1250 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1255 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " 1251 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: "
1256 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr); 1252 "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
1257 ecc_failed++; 1253 ecc_failed++;
1258 } 1254 }
1259 } else { 1255 } else {
@@ -1274,7 +1270,7 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1274 for (j = 0; j < oobsel->eccbytes; j++) 1270 for (j = 0; j < oobsel->eccbytes; j++)
1275 ecc_code[j] = oob_data[oob_config[j]]; 1271 ecc_code[j] = oob_data[oob_config[j]];
1276 1272
1277 /* correct data, if neccecary */ 1273 /* correct data, if necessary */
1278 for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) { 1274 for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
1279 ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]); 1275 ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
1280 1276
@@ -1291,16 +1287,16 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1291 } 1287 }
1292 1288
1293 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) { 1289 if ((ecc_status == -1) || (ecc_status > (flags && 0xff))) {
1294 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page); 1290 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
1295 ecc_failed++; 1291 ecc_failed++;
1296 } 1292 }
1297 } 1293 }
1298 1294
1299 readoob: 1295 readoob:
1300 /* check, if we have a fs supplied oob-buffer */ 1296 /* check, if we have a fs supplied oob-buffer */
1301 if (oob_buf) { 1297 if (oob_buf) {
1302 /* without autoplace. Legacy mode used by YAFFS1 */ 1298 /* without autoplace. Legacy mode used by YAFFS1 */
1303 switch(oobsel->useecc) { 1299 switch (oobsel->useecc) {
1304 case MTD_NANDECC_AUTOPLACE: 1300 case MTD_NANDECC_AUTOPLACE:
1305 case MTD_NANDECC_AUTOPL_USR: 1301 case MTD_NANDECC_AUTOPL_USR:
1306 /* Walk through the autoplace chunks */ 1302 /* Walk through the autoplace chunks */
@@ -1313,7 +1309,7 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1313 break; 1309 break;
1314 case MTD_NANDECC_PLACE: 1310 case MTD_NANDECC_PLACE:
1315 /* YAFFS1 legacy mode */ 1311 /* YAFFS1 legacy mode */
1316 oob_data += this->eccsteps * sizeof (int); 1312 oob_data += this->eccsteps * sizeof(int);
1317 default: 1313 default:
1318 oob_data += mtd->oobsize; 1314 oob_data += mtd->oobsize;
1319 } 1315 }
@@ -1331,9 +1327,9 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1331 * Do this before the AUTOINCR check, so no problems 1327 * Do this before the AUTOINCR check, so no problems
1332 * arise if a chip which does auto increment 1328 * arise if a chip which does auto increment
1333 * is marked as NOAUTOINCR by the board driver. 1329 * is marked as NOAUTOINCR by the board driver.
1334 */ 1330 */
1335 if (!this->dev_ready) 1331 if (!this->dev_ready)
1336 udelay (this->chip_delay); 1332 udelay(this->chip_delay);
1337 else 1333 else
1338 nand_wait_ready(mtd); 1334 nand_wait_ready(mtd);
1339 1335
@@ -1354,7 +1350,7 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1354 } 1350 }
1355 /* Check, if the chip supports auto page increment 1351 /* Check, if the chip supports auto page increment
1356 * or if we have hit a block boundary. 1352 * or if we have hit a block boundary.
1357 */ 1353 */
1358 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) 1354 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
1359 sndcmd = 1; 1355 sndcmd = 1;
1360 } 1356 }
@@ -1382,13 +1378,13 @@ int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
1382 * 1378 *
1383 * NAND read out-of-band data from the spare area 1379 * NAND read out-of-band data from the spare area
1384 */ 1380 */
1385static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf) 1381static int nand_read_oob(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1386{ 1382{
1387 int i, col, page, chipnr; 1383 int i, col, page, chipnr;
1388 struct nand_chip *this = mtd->priv; 1384 struct nand_chip *this = mtd->priv;
1389 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1; 1385 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1390 1386
1391 DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len); 1387 DEBUG(MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i\n", (unsigned int)from, (int)len);
1392 1388
1393 /* Shift to get page */ 1389 /* Shift to get page */
1394 page = (int)(from >> this->page_shift); 1390 page = (int)(from >> this->page_shift);
@@ -1402,19 +1398,19 @@ static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t
1402 1398
1403 /* Do not allow reads past end of device */ 1399 /* Do not allow reads past end of device */
1404 if ((from + len) > mtd->size) { 1400 if ((from + len) > mtd->size) {
1405 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n"); 1401 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device\n");
1406 *retlen = 0; 1402 *retlen = 0;
1407 return -EINVAL; 1403 return -EINVAL;
1408 } 1404 }
1409 1405
1410 /* Grab the lock and see if the device is available */ 1406 /* Grab the lock and see if the device is available */
1411 nand_get_device (this, mtd , FL_READING); 1407 nand_get_device(this, mtd, FL_READING);
1412 1408
1413 /* Select the NAND device */ 1409 /* Select the NAND device */
1414 this->select_chip(mtd, chipnr); 1410 this->select_chip(mtd, chipnr);
1415 1411
1416 /* Send the read command */ 1412 /* Send the read command */
1417 this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask); 1413 this->cmdfunc(mtd, NAND_CMD_READOOB, col, page & this->pagemask);
1418 /* 1414 /*
1419 * Read the data, if we read more than one page 1415 * Read the data, if we read more than one page
1420 * oob data, let the device transfer the data ! 1416 * oob data, let the device transfer the data !
@@ -1444,16 +1440,16 @@ static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t
1444 * is marked as NOAUTOINCR by the board driver. 1440 * is marked as NOAUTOINCR by the board driver.
1445 */ 1441 */
1446 if (!this->dev_ready) 1442 if (!this->dev_ready)
1447 udelay (this->chip_delay); 1443 udelay(this->chip_delay);
1448 else 1444 else
1449 nand_wait_ready(mtd); 1445 nand_wait_ready(mtd);
1450 1446
1451 /* Check, if the chip supports auto page increment 1447 /* Check, if the chip supports auto page increment
1452 * or if we have hit a block boundary. 1448 * or if we have hit a block boundary.
1453 */ 1449 */
1454 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) { 1450 if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
1455 /* For subsequent page reads set offset to 0 */ 1451 /* For subsequent page reads set offset to 0 */
1456 this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask); 1452 this->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
1457 } 1453 }
1458 } 1454 }
1459 } 1455 }
@@ -1476,43 +1472,43 @@ static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t
1476 * 1472 *
1477 * Read raw data including oob into buffer 1473 * Read raw data including oob into buffer
1478 */ 1474 */
1479int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen) 1475int nand_read_raw(struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len, size_t ooblen)
1480{ 1476{
1481 struct nand_chip *this = mtd->priv; 1477 struct nand_chip *this = mtd->priv;
1482 int page = (int) (from >> this->page_shift); 1478 int page = (int)(from >> this->page_shift);
1483 int chip = (int) (from >> this->chip_shift); 1479 int chip = (int)(from >> this->chip_shift);
1484 int sndcmd = 1; 1480 int sndcmd = 1;
1485 int cnt = 0; 1481 int cnt = 0;
1486 int pagesize = mtd->oobblock + mtd->oobsize; 1482 int pagesize = mtd->oobblock + mtd->oobsize;
1487 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1; 1483 int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
1488 1484
1489 /* Do not allow reads past end of device */ 1485 /* Do not allow reads past end of device */
1490 if ((from + len) > mtd->size) { 1486 if ((from + len) > mtd->size) {
1491 DEBUG (MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n"); 1487 DEBUG(MTD_DEBUG_LEVEL0, "nand_read_raw: Attempt read beyond end of device\n");
1492 return -EINVAL; 1488 return -EINVAL;
1493 } 1489 }
1494 1490
1495 /* Grab the lock and see if the device is available */ 1491 /* Grab the lock and see if the device is available */
1496 nand_get_device (this, mtd , FL_READING); 1492 nand_get_device(this, mtd, FL_READING);
1497 1493
1498 this->select_chip (mtd, chip); 1494 this->select_chip(mtd, chip);
1499 1495
1500 /* Add requested oob length */ 1496 /* Add requested oob length */
1501 len += ooblen; 1497 len += ooblen;
1502 1498
1503 while (len) { 1499 while (len) {
1504 if (sndcmd) 1500 if (sndcmd)
1505 this->cmdfunc (mtd, NAND_CMD_READ0, 0, page & this->pagemask); 1501 this->cmdfunc(mtd, NAND_CMD_READ0, 0, page & this->pagemask);
1506 sndcmd = 0; 1502 sndcmd = 0;
1507 1503
1508 this->read_buf (mtd, &buf[cnt], pagesize); 1504 this->read_buf(mtd, &buf[cnt], pagesize);
1509 1505
1510 len -= pagesize; 1506 len -= pagesize;
1511 cnt += pagesize; 1507 cnt += pagesize;
1512 page++; 1508 page++;
1513 1509
1514 if (!this->dev_ready) 1510 if (!this->dev_ready)
1515 udelay (this->chip_delay); 1511 udelay(this->chip_delay);
1516 else 1512 else
1517 nand_wait_ready(mtd); 1513 nand_wait_ready(mtd);
1518 1514
@@ -1526,7 +1522,6 @@ int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len,
1526 return 0; 1522 return 0;
1527} 1523}
1528 1524
1529
1530/** 1525/**
1531 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer 1526 * nand_prepare_oobbuf - [GENERIC] Prepare the out of band buffer
1532 * @mtd: MTD device structure 1527 * @mtd: MTD device structure
@@ -1550,8 +1545,8 @@ int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_t len,
1550 * forces the 0xff fill before using the buffer again. 1545 * forces the 0xff fill before using the buffer again.
1551 * 1546 *
1552*/ 1547*/
1553static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel, 1548static u_char *nand_prepare_oobbuf(struct mtd_info *mtd, u_char *fsbuf, struct nand_oobinfo *oobsel,
1554 int autoplace, int numpages) 1549 int autoplace, int numpages)
1555{ 1550{
1556 struct nand_chip *this = mtd->priv; 1551 struct nand_chip *this = mtd->priv;
1557 int i, len, ofs; 1552 int i, len, ofs;
@@ -1562,8 +1557,7 @@ static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct
1562 1557
1563 /* Check, if the buffer must be filled with ff again */ 1558 /* Check, if the buffer must be filled with ff again */
1564 if (this->oobdirty) { 1559 if (this->oobdirty) {
1565 memset (this->oob_buf, 0xff, 1560 memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1566 mtd->oobsize << (this->phys_erase_shift - this->page_shift));
1567 this->oobdirty = 0; 1561 this->oobdirty = 0;
1568 } 1562 }
1569 1563
@@ -1578,7 +1572,7 @@ static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct
1578 for (i = 0, len = 0; len < mtd->oobavail; i++) { 1572 for (i = 0, len = 0; len < mtd->oobavail; i++) {
1579 int to = ofs + oobsel->oobfree[i][0]; 1573 int to = ofs + oobsel->oobfree[i][0];
1580 int num = oobsel->oobfree[i][1]; 1574 int num = oobsel->oobfree[i][1];
1581 memcpy (&this->oob_buf[to], fsbuf, num); 1575 memcpy(&this->oob_buf[to], fsbuf, num);
1582 len += num; 1576 len += num;
1583 fsbuf += num; 1577 fsbuf += num;
1584 } 1578 }
@@ -1600,9 +1594,9 @@ static u_char * nand_prepare_oobbuf (struct mtd_info *mtd, u_char *fsbuf, struct
1600 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL 1594 * This function simply calls nand_write_ecc with oob buffer and oobsel = NULL
1601 * 1595 *
1602*/ 1596*/
1603static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf) 1597static int nand_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
1604{ 1598{
1605 return (nand_write_ecc (mtd, to, len, retlen, buf, NULL, NULL)); 1599 return (nand_write_ecc(mtd, to, len, retlen, buf, NULL, NULL));
1606} 1600}
1607 1601
1608/** 1602/**
@@ -1617,34 +1611,35 @@ static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, size_t * ret
1617 * 1611 *
1618 * NAND write with ECC 1612 * NAND write with ECC
1619 */ 1613 */
1620static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len, 1614static int nand_write_ecc(struct mtd_info *mtd, loff_t to, size_t len,
1621 size_t * retlen, const u_char * buf, u_char * eccbuf, struct nand_oobinfo *oobsel) 1615 size_t *retlen, const u_char *buf, u_char *eccbuf,
1616 struct nand_oobinfo *oobsel)
1622{ 1617{
1623 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr; 1618 int startpage, page, ret = -EIO, oob = 0, written = 0, chipnr;
1624 int autoplace = 0, numpages, totalpages; 1619 int autoplace = 0, numpages, totalpages;
1625 struct nand_chip *this = mtd->priv; 1620 struct nand_chip *this = mtd->priv;
1626 u_char *oobbuf, *bufstart; 1621 u_char *oobbuf, *bufstart;
1627 int ppblock = (1 << (this->phys_erase_shift - this->page_shift)); 1622 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1628 1623
1629 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len); 1624 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_ecc: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1630 1625
1631 /* Initialize retlen, in case of early exit */ 1626 /* Initialize retlen, in case of early exit */
1632 *retlen = 0; 1627 *retlen = 0;
1633 1628
1634 /* Do not allow write past end of device */ 1629 /* Do not allow write past end of device */
1635 if ((to + len) > mtd->size) { 1630 if ((to + len) > mtd->size) {
1636 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n"); 1631 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: Attempt to write past end of page\n");
1637 return -EINVAL; 1632 return -EINVAL;
1638 } 1633 }
1639 1634
1640 /* reject writes, which are not page aligned */ 1635 /* reject writes, which are not page aligned */
1641 if (NOTALIGNED (to) || NOTALIGNED(len)) { 1636 if (NOTALIGNED(to) || NOTALIGNED(len)) {
1642 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n"); 1637 printk(KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1643 return -EINVAL; 1638 return -EINVAL;
1644 } 1639 }
1645 1640
1646 /* Grab the lock and see if the device is available */ 1641 /* Grab the lock and see if the device is available */
1647 nand_get_device (this, mtd, FL_WRITING); 1642 nand_get_device(this, mtd, FL_WRITING);
1648 1643
1649 /* Calculate chipnr */ 1644 /* Calculate chipnr */
1650 chipnr = (int)(to >> this->chip_shift); 1645 chipnr = (int)(to >> this->chip_shift);
@@ -1669,7 +1664,7 @@ static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1669 1664
1670 /* Setup variables and oob buffer */ 1665 /* Setup variables and oob buffer */
1671 totalpages = len >> this->page_shift; 1666 totalpages = len >> this->page_shift;
1672 page = (int) (to >> this->page_shift); 1667 page = (int)(to >> this->page_shift);
1673 /* Invalidate the page cache, if we write to the cached page */ 1668 /* Invalidate the page cache, if we write to the cached page */
1674 if (page <= this->pagebuf && this->pagebuf < (page + totalpages)) 1669 if (page <= this->pagebuf && this->pagebuf < (page + totalpages))
1675 this->pagebuf = -1; 1670 this->pagebuf = -1;
@@ -1678,22 +1673,22 @@ static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1678 page &= this->pagemask; 1673 page &= this->pagemask;
1679 startpage = page; 1674 startpage = page;
1680 /* Calc number of pages we can write in one go */ 1675 /* Calc number of pages we can write in one go */
1681 numpages = min (ppblock - (startpage & (ppblock - 1)), totalpages); 1676 numpages = min(ppblock - (startpage & (ppblock - 1)), totalpages);
1682 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, autoplace, numpages); 1677 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1683 bufstart = (u_char *)buf; 1678 bufstart = (u_char *) buf;
1684 1679
1685 /* Loop until all data is written */ 1680 /* Loop until all data is written */
1686 while (written < len) { 1681 while (written < len) {
1687 1682
1688 this->data_poi = (u_char*) &buf[written]; 1683 this->data_poi = (u_char *) &buf[written];
1689 /* Write one page. If this is the last page to write 1684 /* Write one page. If this is the last page to write
1690 * or the last page in this block, then use the 1685 * or the last page in this block, then use the
1691 * real pageprogram command, else select cached programming 1686 * real pageprogram command, else select cached programming
1692 * if supported by the chip. 1687 * if supported by the chip.
1693 */ 1688 */
1694 ret = nand_write_page (mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0)); 1689 ret = nand_write_page(mtd, this, page, &oobbuf[oob], oobsel, (--numpages > 0));
1695 if (ret) { 1690 if (ret) {
1696 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret); 1691 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: write_page failed %d\n", ret);
1697 goto out; 1692 goto out;
1698 } 1693 }
1699 /* Next oob page */ 1694 /* Next oob page */
@@ -1709,15 +1704,14 @@ static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1709 /* Have we hit a block boundary ? Then we have to verify and 1704 /* Have we hit a block boundary ? Then we have to verify and
1710 * if verify is ok, we have to setup the oob buffer for 1705 * if verify is ok, we have to setup the oob buffer for
1711 * the next pages. 1706 * the next pages.
1712 */ 1707 */
1713 if (!(page & (ppblock - 1))){ 1708 if (!(page & (ppblock - 1))) {
1714 int ofs; 1709 int ofs;
1715 this->data_poi = bufstart; 1710 this->data_poi = bufstart;
1716 ret = nand_verify_pages (mtd, this, startpage, 1711 ret = nand_verify_pages(mtd, this, startpage, page - startpage,
1717 page - startpage, 1712 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1718 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1719 if (ret) { 1713 if (ret) {
1720 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret); 1714 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1721 goto out; 1715 goto out;
1722 } 1716 }
1723 *retlen = written; 1717 *retlen = written;
@@ -1726,11 +1720,10 @@ static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1726 if (eccbuf) 1720 if (eccbuf)
1727 eccbuf += (page - startpage) * ofs; 1721 eccbuf += (page - startpage) * ofs;
1728 totalpages -= page - startpage; 1722 totalpages -= page - startpage;
1729 numpages = min (totalpages, ppblock); 1723 numpages = min(totalpages, ppblock);
1730 page &= this->pagemask; 1724 page &= this->pagemask;
1731 startpage = page; 1725 startpage = page;
1732 oobbuf = nand_prepare_oobbuf (mtd, eccbuf, oobsel, 1726 oobbuf = nand_prepare_oobbuf(mtd, eccbuf, oobsel, autoplace, numpages);
1733 autoplace, numpages);
1734 oob = 0; 1727 oob = 0;
1735 /* Check, if we cross a chip boundary */ 1728 /* Check, if we cross a chip boundary */
1736 if (!page) { 1729 if (!page) {
@@ -1741,23 +1734,21 @@ static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
1741 } 1734 }
1742 } 1735 }
1743 /* Verify the remaining pages */ 1736 /* Verify the remaining pages */
1744cmp: 1737 cmp:
1745 this->data_poi = bufstart; 1738 this->data_poi = bufstart;
1746 ret = nand_verify_pages (mtd, this, startpage, totalpages, 1739 ret = nand_verify_pages(mtd, this, startpage, totalpages, oobbuf, oobsel, chipnr, (eccbuf != NULL));
1747 oobbuf, oobsel, chipnr, (eccbuf != NULL));
1748 if (!ret) 1740 if (!ret)
1749 *retlen = written; 1741 *retlen = written;
1750 else 1742 else
1751 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret); 1743 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_ecc: verify_pages failed %d\n", ret);
1752 1744
1753out: 1745 out:
1754 /* Deselect and wake up anyone waiting on the device */ 1746 /* Deselect and wake up anyone waiting on the device */
1755 nand_release_device(mtd); 1747 nand_release_device(mtd);
1756 1748
1757 return ret; 1749 return ret;
1758} 1750}
1759 1751
1760
1761/** 1752/**
1762 * nand_write_oob - [MTD Interface] NAND write out-of-band 1753 * nand_write_oob - [MTD Interface] NAND write out-of-band
1763 * @mtd: MTD device structure 1754 * @mtd: MTD device structure
@@ -1768,16 +1759,16 @@ out:
1768 * 1759 *
1769 * NAND write out-of-band 1760 * NAND write out-of-band
1770 */ 1761 */
1771static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t * retlen, const u_char * buf) 1762static int nand_write_oob(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
1772{ 1763{
1773 int column, page, status, ret = -EIO, chipnr; 1764 int column, page, status, ret = -EIO, chipnr;
1774 struct nand_chip *this = mtd->priv; 1765 struct nand_chip *this = mtd->priv;
1775 1766
1776 DEBUG (MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len); 1767 DEBUG(MTD_DEBUG_LEVEL3, "nand_write_oob: to = 0x%08x, len = %i\n", (unsigned int)to, (int)len);
1777 1768
1778 /* Shift to get page */ 1769 /* Shift to get page */
1779 page = (int) (to >> this->page_shift); 1770 page = (int)(to >> this->page_shift);
1780 chipnr = (int) (to >> this->chip_shift); 1771 chipnr = (int)(to >> this->chip_shift);
1781 1772
1782 /* Mask to get column */ 1773 /* Mask to get column */
1783 column = to & (mtd->oobsize - 1); 1774 column = to & (mtd->oobsize - 1);
@@ -1787,12 +1778,12 @@ static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t *
1787 1778
1788 /* Do not allow write past end of page */ 1779 /* Do not allow write past end of page */
1789 if ((column + len) > mtd->oobsize) { 1780 if ((column + len) > mtd->oobsize) {
1790 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n"); 1781 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: Attempt to write past end of page\n");
1791 return -EINVAL; 1782 return -EINVAL;
1792 } 1783 }
1793 1784
1794 /* Grab the lock and see if the device is available */ 1785 /* Grab the lock and see if the device is available */
1795 nand_get_device (this, mtd, FL_WRITING); 1786 nand_get_device(this, mtd, FL_WRITING);
1796 1787
1797 /* Select the NAND device */ 1788 /* Select the NAND device */
1798 this->select_chip(mtd, chipnr); 1789 this->select_chip(mtd, chipnr);
@@ -1814,27 +1805,27 @@ static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t *
1814 1805
1815 if (NAND_MUST_PAD(this)) { 1806 if (NAND_MUST_PAD(this)) {
1816 /* Write out desired data */ 1807 /* Write out desired data */
1817 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask); 1808 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->oobblock, page & this->pagemask);
1818 /* prepad 0xff for partial programming */ 1809 /* prepad 0xff for partial programming */
1819 this->write_buf(mtd, ffchars, column); 1810 this->write_buf(mtd, ffchars, column);
1820 /* write data */ 1811 /* write data */
1821 this->write_buf(mtd, buf, len); 1812 this->write_buf(mtd, buf, len);
1822 /* postpad 0xff for partial programming */ 1813 /* postpad 0xff for partial programming */
1823 this->write_buf(mtd, ffchars, mtd->oobsize - (len+column)); 1814 this->write_buf(mtd, ffchars, mtd->oobsize - (len + column));
1824 } else { 1815 } else {
1825 /* Write out desired data */ 1816 /* Write out desired data */
1826 this->cmdfunc (mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask); 1817 this->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->oobblock + column, page & this->pagemask);
1827 /* write data */ 1818 /* write data */
1828 this->write_buf(mtd, buf, len); 1819 this->write_buf(mtd, buf, len);
1829 } 1820 }
1830 /* Send command to program the OOB data */ 1821 /* Send command to program the OOB data */
1831 this->cmdfunc (mtd, NAND_CMD_PAGEPROG, -1, -1); 1822 this->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
1832 1823
1833 status = this->waitfunc (mtd, this, FL_WRITING); 1824 status = this->waitfunc(mtd, this, FL_WRITING);
1834 1825
1835 /* See if device thinks it succeeded */ 1826 /* See if device thinks it succeeded */
1836 if (status & NAND_STATUS_FAIL) { 1827 if (status & NAND_STATUS_FAIL) {
1837 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page); 1828 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write, page 0x%08x\n", page);
1838 ret = -EIO; 1829 ret = -EIO;
1839 goto out; 1830 goto out;
1840 } 1831 }
@@ -1843,23 +1834,22 @@ static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, size_t *
1843 1834
1844#ifdef CONFIG_MTD_NAND_VERIFY_WRITE 1835#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
1845 /* Send command to read back the data */ 1836 /* Send command to read back the data */
1846 this->cmdfunc (mtd, NAND_CMD_READOOB, column, page & this->pagemask); 1837 this->cmdfunc(mtd, NAND_CMD_READOOB, column, page & this->pagemask);
1847 1838
1848 if (this->verify_buf(mtd, buf, len)) { 1839 if (this->verify_buf(mtd, buf, len)) {
1849 DEBUG (MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page); 1840 DEBUG(MTD_DEBUG_LEVEL0, "nand_write_oob: " "Failed write verify, page 0x%08x\n", page);
1850 ret = -EIO; 1841 ret = -EIO;
1851 goto out; 1842 goto out;
1852 } 1843 }
1853#endif 1844#endif
1854 ret = 0; 1845 ret = 0;
1855out: 1846 out:
1856 /* Deselect and wake up anyone waiting on the device */ 1847 /* Deselect and wake up anyone waiting on the device */
1857 nand_release_device(mtd); 1848 nand_release_device(mtd);
1858 1849
1859 return ret; 1850 return ret;
1860} 1851}
1861 1852
1862
1863/** 1853/**
1864 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc 1854 * nand_writev - [MTD Interface] compabilty function for nand_writev_ecc
1865 * @mtd: MTD device structure 1855 * @mtd: MTD device structure
@@ -1870,10 +1860,10 @@ out:
1870 * 1860 *
1871 * NAND write with kvec. This just calls the ecc function 1861 * NAND write with kvec. This just calls the ecc function
1872 */ 1862 */
1873static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, 1863static int nand_writev(struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1874 loff_t to, size_t * retlen) 1864 loff_t to, size_t *retlen)
1875{ 1865{
1876 return (nand_writev_ecc (mtd, vecs, count, to, retlen, NULL, NULL)); 1866 return (nand_writev_ecc(mtd, vecs, count, to, retlen, NULL, NULL));
1877} 1867}
1878 1868
1879/** 1869/**
@@ -1888,13 +1878,13 @@ static int nand_writev (struct mtd_info *mtd, const struct kvec *vecs, unsigned
1888 * 1878 *
1889 * NAND write with iovec with ecc 1879 * NAND write with iovec with ecc
1890 */ 1880 */
1891static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, 1881static int nand_writev_ecc(struct mtd_info *mtd, const struct kvec *vecs, unsigned long count,
1892 loff_t to, size_t * retlen, u_char *eccbuf, struct nand_oobinfo *oobsel) 1882 loff_t to, size_t *retlen, u_char *eccbuf, struct nand_oobinfo *oobsel)
1893{ 1883{
1894 int i, page, len, total_len, ret = -EIO, written = 0, chipnr; 1884 int i, page, len, total_len, ret = -EIO, written = 0, chipnr;
1895 int oob, numpages, autoplace = 0, startpage; 1885 int oob, numpages, autoplace = 0, startpage;
1896 struct nand_chip *this = mtd->priv; 1886 struct nand_chip *this = mtd->priv;
1897 int ppblock = (1 << (this->phys_erase_shift - this->page_shift)); 1887 int ppblock = (1 << (this->phys_erase_shift - this->page_shift));
1898 u_char *oobbuf, *bufstart; 1888 u_char *oobbuf, *bufstart;
1899 1889
1900 /* Preset written len for early exit */ 1890 /* Preset written len for early exit */
@@ -1903,28 +1893,27 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1903 /* Calculate total length of data */ 1893 /* Calculate total length of data */
1904 total_len = 0; 1894 total_len = 0;
1905 for (i = 0; i < count; i++) 1895 for (i = 0; i < count; i++)
1906 total_len += (int) vecs[i].iov_len; 1896 total_len += (int)vecs[i].iov_len;
1907 1897
1908 DEBUG (MTD_DEBUG_LEVEL3, 1898 DEBUG(MTD_DEBUG_LEVEL3, "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int)to, (unsigned int)total_len, count);
1909 "nand_writev: to = 0x%08x, len = %i, count = %ld\n", (unsigned int) to, (unsigned int) total_len, count);
1910 1899
1911 /* Do not allow write past end of page */ 1900 /* Do not allow write past end of page */
1912 if ((to + total_len) > mtd->size) { 1901 if ((to + total_len) > mtd->size) {
1913 DEBUG (MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n"); 1902 DEBUG(MTD_DEBUG_LEVEL0, "nand_writev: Attempted write past end of device\n");
1914 return -EINVAL; 1903 return -EINVAL;
1915 } 1904 }
1916 1905
1917 /* reject writes, which are not page aligned */ 1906 /* reject writes, which are not page aligned */
1918 if (NOTALIGNED (to) || NOTALIGNED(total_len)) { 1907 if (NOTALIGNED(to) || NOTALIGNED(total_len)) {
1919 printk (KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n"); 1908 printk(KERN_NOTICE "nand_write_ecc: Attempt to write not page aligned data\n");
1920 return -EINVAL; 1909 return -EINVAL;
1921 } 1910 }
1922 1911
1923 /* Grab the lock and see if the device is available */ 1912 /* Grab the lock and see if the device is available */
1924 nand_get_device (this, mtd, FL_WRITING); 1913 nand_get_device(this, mtd, FL_WRITING);
1925 1914
1926 /* Get the current chip-nr */ 1915 /* Get the current chip-nr */
1927 chipnr = (int) (to >> this->chip_shift); 1916 chipnr = (int)(to >> this->chip_shift);
1928 /* Select the NAND device */ 1917 /* Select the NAND device */
1929 this->select_chip(mtd, chipnr); 1918 this->select_chip(mtd, chipnr);
1930 1919
@@ -1945,7 +1934,7 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1945 autoplace = 1; 1934 autoplace = 1;
1946 1935
1947 /* Setup start page */ 1936 /* Setup start page */
1948 page = (int) (to >> this->page_shift); 1937 page = (int)(to >> this->page_shift);
1949 /* Invalidate the page cache, if we write to the cached page */ 1938 /* Invalidate the page cache, if we write to the cached page */
1950 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift)) 1939 if (page <= this->pagebuf && this->pagebuf < ((to + total_len) >> this->page_shift))
1951 this->pagebuf = -1; 1940 this->pagebuf = -1;
@@ -1963,9 +1952,9 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1963 * out of this iov in one go */ 1952 * out of this iov in one go */
1964 numpages = (vecs->iov_len - len) >> this->page_shift; 1953 numpages = (vecs->iov_len - len) >> this->page_shift;
1965 /* Do not cross block boundaries */ 1954 /* Do not cross block boundaries */
1966 numpages = min (ppblock - (startpage & (ppblock - 1)), numpages); 1955 numpages = min(ppblock - (startpage & (ppblock - 1)), numpages);
1967 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages); 1956 oobbuf = nand_prepare_oobbuf(mtd, NULL, oobsel, autoplace, numpages);
1968 bufstart = (u_char *)vecs->iov_base; 1957 bufstart = (u_char *) vecs->iov_base;
1969 bufstart += len; 1958 bufstart += len;
1970 this->data_poi = bufstart; 1959 this->data_poi = bufstart;
1971 oob = 0; 1960 oob = 0;
@@ -1974,8 +1963,8 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1974 * then use the real pageprogram command, else select 1963 * then use the real pageprogram command, else select
1975 * cached programming if supported by the chip. 1964 * cached programming if supported by the chip.
1976 */ 1965 */
1977 ret = nand_write_page (mtd, this, page & this->pagemask, 1966 ret = nand_write_page(mtd, this, page & this->pagemask,
1978 &oobbuf[oob], oobsel, i != numpages); 1967 &oobbuf[oob], oobsel, i != numpages);
1979 if (ret) 1968 if (ret)
1980 goto out; 1969 goto out;
1981 this->data_poi += mtd->oobblock; 1970 this->data_poi += mtd->oobblock;
@@ -1984,7 +1973,7 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1984 page++; 1973 page++;
1985 } 1974 }
1986 /* Check, if we have to switch to the next tuple */ 1975 /* Check, if we have to switch to the next tuple */
1987 if (len >= (int) vecs->iov_len) { 1976 if (len >= (int)vecs->iov_len) {
1988 vecs++; 1977 vecs++;
1989 len = 0; 1978 len = 0;
1990 count--; 1979 count--;
@@ -1998,7 +1987,7 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
1998 if (vecs->iov_base != NULL && vecs->iov_len) 1987 if (vecs->iov_base != NULL && vecs->iov_len)
1999 this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++]; 1988 this->data_buf[cnt++] = ((u_char *) vecs->iov_base)[len++];
2000 /* Check, if we have to switch to the next tuple */ 1989 /* Check, if we have to switch to the next tuple */
2001 if (len >= (int) vecs->iov_len) { 1990 if (len >= (int)vecs->iov_len) {
2002 vecs++; 1991 vecs++;
2003 len = 0; 1992 len = 0;
2004 count--; 1993 count--;
@@ -2008,16 +1997,15 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
2008 this->data_poi = this->data_buf; 1997 this->data_poi = this->data_buf;
2009 bufstart = this->data_poi; 1998 bufstart = this->data_poi;
2010 numpages = 1; 1999 numpages = 1;
2011 oobbuf = nand_prepare_oobbuf (mtd, NULL, oobsel, autoplace, numpages); 2000 oobbuf = nand_prepare_oobbuf(mtd, NULL, oobsel, autoplace, numpages);
2012 ret = nand_write_page (mtd, this, page & this->pagemask, 2001 ret = nand_write_page(mtd, this, page & this->pagemask, oobbuf, oobsel, 0);
2013 oobbuf, oobsel, 0);
2014 if (ret) 2002 if (ret)
2015 goto out; 2003 goto out;
2016 page++; 2004 page++;
2017 } 2005 }
2018 2006
2019 this->data_poi = bufstart; 2007 this->data_poi = bufstart;
2020 ret = nand_verify_pages (mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0); 2008 ret = nand_verify_pages(mtd, this, startpage, numpages, oobbuf, oobsel, chipnr, 0);
2021 if (ret) 2009 if (ret)
2022 goto out; 2010 goto out;
2023 2011
@@ -2035,7 +2023,7 @@ static int nand_writev_ecc (struct mtd_info *mtd, const struct kvec *vecs, unsig
2035 } 2023 }
2036 } 2024 }
2037 ret = 0; 2025 ret = 0;
2038out: 2026 out:
2039 /* Deselect and wake up anyone waiting on the device */ 2027 /* Deselect and wake up anyone waiting on the device */
2040 nand_release_device(mtd); 2028 nand_release_device(mtd);
2041 2029
@@ -2050,12 +2038,12 @@ out:
2050 * 2038 *
2051 * Standard erase command for NAND chips 2039 * Standard erase command for NAND chips
2052 */ 2040 */
2053static void single_erase_cmd (struct mtd_info *mtd, int page) 2041static void single_erase_cmd(struct mtd_info *mtd, int page)
2054{ 2042{
2055 struct nand_chip *this = mtd->priv; 2043 struct nand_chip *this = mtd->priv;
2056 /* Send commands to erase a block */ 2044 /* Send commands to erase a block */
2057 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page); 2045 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2058 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1); 2046 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2059} 2047}
2060 2048
2061/** 2049/**
@@ -2066,15 +2054,15 @@ static void single_erase_cmd (struct mtd_info *mtd, int page)
2066 * AND multi block erase command function 2054 * AND multi block erase command function
2067 * Erase 4 consecutive blocks 2055 * Erase 4 consecutive blocks
2068 */ 2056 */
2069static void multi_erase_cmd (struct mtd_info *mtd, int page) 2057static void multi_erase_cmd(struct mtd_info *mtd, int page)
2070{ 2058{
2071 struct nand_chip *this = mtd->priv; 2059 struct nand_chip *this = mtd->priv;
2072 /* Send commands to erase a block */ 2060 /* Send commands to erase a block */
2073 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++); 2061 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2074 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++); 2062 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2075 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page++); 2063 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page++);
2076 this->cmdfunc (mtd, NAND_CMD_ERASE1, -1, page); 2064 this->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
2077 this->cmdfunc (mtd, NAND_CMD_ERASE2, -1, -1); 2065 this->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
2078} 2066}
2079 2067
2080/** 2068/**
@@ -2084,9 +2072,9 @@ static void multi_erase_cmd (struct mtd_info *mtd, int page)
2084 * 2072 *
2085 * Erase one ore more blocks 2073 * Erase one ore more blocks
2086 */ 2074 */
2087static int nand_erase (struct mtd_info *mtd, struct erase_info *instr) 2075static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
2088{ 2076{
2089 return nand_erase_nand (mtd, instr, 0); 2077 return nand_erase_nand(mtd, instr, 0);
2090} 2078}
2091 2079
2092#define BBT_PAGE_MASK 0xffffff3f 2080#define BBT_PAGE_MASK 0xffffff3f
@@ -2098,7 +2086,7 @@ static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
2098 * 2086 *
2099 * Erase one ore more blocks 2087 * Erase one ore more blocks
2100 */ 2088 */
2101int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt) 2089int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr, int allowbbt)
2102{ 2090{
2103 int page, len, status, pages_per_block, ret, chipnr; 2091 int page, len, status, pages_per_block, ret, chipnr;
2104 struct nand_chip *this = mtd->priv; 2092 struct nand_chip *this = mtd->priv;
@@ -2107,35 +2095,34 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2107 /* It is used to see if the current page is in the same */ 2095 /* It is used to see if the current page is in the same */
2108 /* 256 block group and the same bank as the bbt. */ 2096 /* 256 block group and the same bank as the bbt. */
2109 2097
2110 DEBUG (MTD_DEBUG_LEVEL3, 2098 DEBUG(MTD_DEBUG_LEVEL3, "nand_erase: start = 0x%08x, len = %i\n", (unsigned int)instr->addr, (unsigned int)instr->len);
2111 "nand_erase: start = 0x%08x, len = %i\n", (unsigned int) instr->addr, (unsigned int) instr->len);
2112 2099
2113 /* Start address must align on block boundary */ 2100 /* Start address must align on block boundary */
2114 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) { 2101 if (instr->addr & ((1 << this->phys_erase_shift) - 1)) {
2115 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n"); 2102 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Unaligned address\n");
2116 return -EINVAL; 2103 return -EINVAL;
2117 } 2104 }
2118 2105
2119 /* Length must align on block boundary */ 2106 /* Length must align on block boundary */
2120 if (instr->len & ((1 << this->phys_erase_shift) - 1)) { 2107 if (instr->len & ((1 << this->phys_erase_shift) - 1)) {
2121 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n"); 2108 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Length not block aligned\n");
2122 return -EINVAL; 2109 return -EINVAL;
2123 } 2110 }
2124 2111
2125 /* Do not allow erase past end of device */ 2112 /* Do not allow erase past end of device */
2126 if ((instr->len + instr->addr) > mtd->size) { 2113 if ((instr->len + instr->addr) > mtd->size) {
2127 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n"); 2114 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Erase past end of device\n");
2128 return -EINVAL; 2115 return -EINVAL;
2129 } 2116 }
2130 2117
2131 instr->fail_addr = 0xffffffff; 2118 instr->fail_addr = 0xffffffff;
2132 2119
2133 /* Grab the lock and see if the device is available */ 2120 /* Grab the lock and see if the device is available */
2134 nand_get_device (this, mtd, FL_ERASING); 2121 nand_get_device(this, mtd, FL_ERASING);
2135 2122
2136 /* Shift to get first page */ 2123 /* Shift to get first page */
2137 page = (int) (instr->addr >> this->page_shift); 2124 page = (int)(instr->addr >> this->page_shift);
2138 chipnr = (int) (instr->addr >> this->chip_shift); 2125 chipnr = (int)(instr->addr >> this->chip_shift);
2139 2126
2140 /* Calculate pages in each block */ 2127 /* Calculate pages in each block */
2141 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift); 2128 pages_per_block = 1 << (this->phys_erase_shift - this->page_shift);
@@ -2146,7 +2133,7 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2146 /* Check the WP bit */ 2133 /* Check the WP bit */
2147 /* Check, if it is write protected */ 2134 /* Check, if it is write protected */
2148 if (nand_check_wp(mtd)) { 2135 if (nand_check_wp(mtd)) {
2149 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n"); 2136 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: Device is write protected!!!\n");
2150 instr->state = MTD_ERASE_FAILED; 2137 instr->state = MTD_ERASE_FAILED;
2151 goto erase_exit; 2138 goto erase_exit;
2152 } 2139 }
@@ -2166,7 +2153,7 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2166 while (len) { 2153 while (len) {
2167 /* Check if we have a bad block, we do not erase bad blocks ! */ 2154 /* Check if we have a bad block, we do not erase bad blocks ! */
2168 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) { 2155 if (nand_block_checkbad(mtd, ((loff_t) page) << this->page_shift, 0, allowbbt)) {
2169 printk (KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page); 2156 printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08x\n", page);
2170 instr->state = MTD_ERASE_FAILED; 2157 instr->state = MTD_ERASE_FAILED;
2171 goto erase_exit; 2158 goto erase_exit;
2172 } 2159 }
@@ -2176,9 +2163,9 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2176 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block)) 2163 if (page <= this->pagebuf && this->pagebuf < (page + pages_per_block))
2177 this->pagebuf = -1; 2164 this->pagebuf = -1;
2178 2165
2179 this->erase_cmd (mtd, page & this->pagemask); 2166 this->erase_cmd(mtd, page & this->pagemask);
2180 2167
2181 status = this->waitfunc (mtd, this, FL_ERASING); 2168 status = this->waitfunc(mtd, this, FL_ERASING);
2182 2169
2183 /* See if operation failed and additional status checks are available */ 2170 /* See if operation failed and additional status checks are available */
2184 if ((status & NAND_STATUS_FAIL) && (this->errstat)) { 2171 if ((status & NAND_STATUS_FAIL) && (this->errstat)) {
@@ -2187,7 +2174,7 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2187 2174
2188 /* See if block erase succeeded */ 2175 /* See if block erase succeeded */
2189 if (status & NAND_STATUS_FAIL) { 2176 if (status & NAND_STATUS_FAIL) {
2190 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page); 2177 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase: " "Failed erase, page 0x%08x\n", page);
2191 instr->state = MTD_ERASE_FAILED; 2178 instr->state = MTD_ERASE_FAILED;
2192 instr->fail_addr = (page << this->page_shift); 2179 instr->fail_addr = (page << this->page_shift);
2193 goto erase_exit; 2180 goto erase_exit;
@@ -2221,7 +2208,7 @@ int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbb
2221 } 2208 }
2222 instr->state = MTD_ERASE_DONE; 2209 instr->state = MTD_ERASE_DONE;
2223 2210
2224erase_exit: 2211 erase_exit:
2225 2212
2226 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO; 2213 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
2227 /* Do call back function */ 2214 /* Do call back function */
@@ -2236,9 +2223,9 @@ erase_exit:
2236 for (chipnr = 0; chipnr < this->numchips; chipnr++) { 2223 for (chipnr = 0; chipnr < this->numchips; chipnr++) {
2237 if (rewrite_bbt[chipnr]) { 2224 if (rewrite_bbt[chipnr]) {
2238 /* update the BBT for chip */ 2225 /* update the BBT for chip */
2239 DEBUG (MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n", 2226 DEBUG(MTD_DEBUG_LEVEL0, "nand_erase_nand: nand_update_bbt (%d:0x%0x 0x%0x)\n",
2240 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]); 2227 chipnr, rewrite_bbt[chipnr], this->bbt_td->pages[chipnr]);
2241 nand_update_bbt (mtd, rewrite_bbt[chipnr]); 2228 nand_update_bbt(mtd, rewrite_bbt[chipnr]);
2242 } 2229 }
2243 } 2230 }
2244 } 2231 }
@@ -2253,31 +2240,30 @@ erase_exit:
2253 * 2240 *
2254 * Sync is actually a wait for chip ready function 2241 * Sync is actually a wait for chip ready function
2255 */ 2242 */
2256static void nand_sync (struct mtd_info *mtd) 2243static void nand_sync(struct mtd_info *mtd)
2257{ 2244{
2258 struct nand_chip *this = mtd->priv; 2245 struct nand_chip *this = mtd->priv;
2259 2246
2260 DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: called\n"); 2247 DEBUG(MTD_DEBUG_LEVEL3, "nand_sync: called\n");
2261 2248
2262 /* Grab the lock and see if the device is available */ 2249 /* Grab the lock and see if the device is available */
2263 nand_get_device (this, mtd, FL_SYNCING); 2250 nand_get_device(this, mtd, FL_SYNCING);
2264 /* Release it and go back */ 2251 /* Release it and go back */
2265 nand_release_device (mtd); 2252 nand_release_device(mtd);
2266} 2253}
2267 2254
2268
2269/** 2255/**
2270 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad 2256 * nand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
2271 * @mtd: MTD device structure 2257 * @mtd: MTD device structure
2272 * @ofs: offset relative to mtd start 2258 * @ofs: offset relative to mtd start
2273 */ 2259 */
2274static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs) 2260static int nand_block_isbad(struct mtd_info *mtd, loff_t ofs)
2275{ 2261{
2276 /* Check for invalid offset */ 2262 /* Check for invalid offset */
2277 if (ofs > mtd->size) 2263 if (ofs > mtd->size)
2278 return -EINVAL; 2264 return -EINVAL;
2279 2265
2280 return nand_block_checkbad (mtd, ofs, 1, 0); 2266 return nand_block_checkbad(mtd, ofs, 1, 0);
2281} 2267}
2282 2268
2283/** 2269/**
@@ -2285,17 +2271,17 @@ static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
2285 * @mtd: MTD device structure 2271 * @mtd: MTD device structure
2286 * @ofs: offset relative to mtd start 2272 * @ofs: offset relative to mtd start
2287 */ 2273 */
2288static int nand_block_markbad (struct mtd_info *mtd, loff_t ofs) 2274static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
2289{ 2275{
2290 struct nand_chip *this = mtd->priv; 2276 struct nand_chip *this = mtd->priv;
2291 int ret; 2277 int ret;
2292 2278
2293 if ((ret = nand_block_isbad(mtd, ofs))) { 2279 if ((ret = nand_block_isbad(mtd, ofs))) {
2294 /* If it was bad already, return success and do nothing. */ 2280 /* If it was bad already, return success and do nothing. */
2295 if (ret > 0) 2281 if (ret > 0)
2296 return 0; 2282 return 0;
2297 return ret; 2283 return ret;
2298 } 2284 }
2299 2285
2300 return this->block_markbad(mtd, ofs); 2286 return this->block_markbad(mtd, ofs);
2301} 2287}
@@ -2308,7 +2294,7 @@ static int nand_suspend(struct mtd_info *mtd)
2308{ 2294{
2309 struct nand_chip *this = mtd->priv; 2295 struct nand_chip *this = mtd->priv;
2310 2296
2311 return nand_get_device (this, mtd, FL_PM_SUSPENDED); 2297 return nand_get_device(this, mtd, FL_PM_SUSPENDED);
2312} 2298}
2313 2299
2314/** 2300/**
@@ -2322,30 +2308,44 @@ static void nand_resume(struct mtd_info *mtd)
2322 if (this->state == FL_PM_SUSPENDED) 2308 if (this->state == FL_PM_SUSPENDED)
2323 nand_release_device(mtd); 2309 nand_release_device(mtd);
2324 else 2310 else
2325 printk(KERN_ERR "resume() called for the chip which is not " 2311 printk(KERN_ERR "resume() called for the chip which is not in suspended state\n");
2326 "in suspended state\n");
2327 2312
2328} 2313}
2329 2314
2315/* module_text_address() isn't exported, and it's mostly a pointless
2316 test if this is a module _anyway_ -- they'd have to try _really_ hard
2317 to call us from in-kernel code if the core NAND support is modular. */
2318#ifdef MODULE
2319#define caller_is_module() (1)
2320#else
2321#define caller_is_module() module_text_address((unsigned long)__builtin_return_address(0))
2322#endif
2330 2323
2331/** 2324/**
2332 * nand_scan - [NAND Interface] Scan for the NAND device 2325 * nand_scan - [NAND Interface] Scan for the NAND device
2333 * @mtd: MTD device structure 2326 * @mtd: MTD device structure
2334 * @maxchips: Number of chips to scan for 2327 * @maxchips: Number of chips to scan for
2335 * 2328 *
2336 * This fills out all the not initialized function pointers 2329 * This fills out all the uninitialized function pointers
2337 * with the defaults. 2330 * with the defaults.
2338 * The flash ID is read and the mtd/chip structures are 2331 * The flash ID is read and the mtd/chip structures are
2339 * filled with the appropriate values. Buffers are allocated if 2332 * filled with the appropriate values. Buffers are allocated if
2340 * they are not provided by the board driver 2333 * they are not provided by the board driver
2334 * The mtd->owner field must be set to the module of the caller
2341 * 2335 *
2342 */ 2336 */
2343int nand_scan (struct mtd_info *mtd, int maxchips) 2337int nand_scan(struct mtd_info *mtd, int maxchips)
2344{ 2338{
2345 int i, nand_maf_id, nand_dev_id, busw, maf_id; 2339 int i, nand_maf_id, nand_dev_id, busw, maf_id;
2346 struct nand_chip *this = mtd->priv; 2340 struct nand_chip *this = mtd->priv;
2347 2341
2348 /* Get buswidth to select the correct functions*/ 2342 /* Many callers got this wrong, so check for it for a while... */
2343 if (!mtd->owner && caller_is_module()) {
2344 printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
2345 BUG();
2346 }
2347
2348 /* Get buswidth to select the correct functions */
2349 busw = this->options & NAND_BUSWIDTH_16; 2349 busw = this->options & NAND_BUSWIDTH_16;
2350 2350
2351 /* check for proper chip_delay setup, set 20us if not */ 2351 /* check for proper chip_delay setup, set 20us if not */
@@ -2387,7 +2387,7 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2387 this->select_chip(mtd, 0); 2387 this->select_chip(mtd, 0);
2388 2388
2389 /* Send the command for reading device ID */ 2389 /* Send the command for reading device ID */
2390 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1); 2390 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2391 2391
2392 /* Read manufacturer and device IDs */ 2392 /* Read manufacturer and device IDs */
2393 nand_maf_id = this->read_byte(mtd); 2393 nand_maf_id = this->read_byte(mtd);
@@ -2399,7 +2399,8 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2399 if (nand_dev_id != nand_flash_ids[i].id) 2399 if (nand_dev_id != nand_flash_ids[i].id)
2400 continue; 2400 continue;
2401 2401
2402 if (!mtd->name) mtd->name = nand_flash_ids[i].name; 2402 if (!mtd->name)
2403 mtd->name = nand_flash_ids[i].name;
2403 this->chipsize = nand_flash_ids[i].chipsize << 20; 2404 this->chipsize = nand_flash_ids[i].chipsize << 20;
2404 2405
2405 /* New devices have all the information in additional id bytes */ 2406 /* New devices have all the information in additional id bytes */
@@ -2416,7 +2417,7 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2416 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->oobblock >> 9); 2417 mtd->oobsize = (8 << (extid & 0x01)) * (mtd->oobblock >> 9);
2417 extid >>= 2; 2418 extid >>= 2;
2418 /* Calc blocksize. Blocksize is multiples of 64KiB */ 2419 /* Calc blocksize. Blocksize is multiples of 64KiB */
2419 mtd->erasesize = (64 * 1024) << (extid & 0x03); 2420 mtd->erasesize = (64 * 1024) << (extid & 0x03);
2420 extid >>= 2; 2421 extid >>= 2;
2421 /* Get buswidth information */ 2422 /* Get buswidth information */
2422 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0; 2423 busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
@@ -2439,13 +2440,12 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2439 /* Check, if buswidth is correct. Hardware drivers should set 2440 /* Check, if buswidth is correct. Hardware drivers should set
2440 * this correct ! */ 2441 * this correct ! */
2441 if (busw != (this->options & NAND_BUSWIDTH_16)) { 2442 if (busw != (this->options & NAND_BUSWIDTH_16)) {
2442 printk (KERN_INFO "NAND device: Manufacturer ID:" 2443 printk(KERN_INFO "NAND device: Manufacturer ID:"
2443 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id, 2444 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
2444 nand_manuf_ids[maf_id].name , mtd->name); 2445 nand_manuf_ids[maf_id].name, mtd->name);
2445 printk (KERN_WARNING 2446 printk(KERN_WARNING
2446 "NAND bus width %d instead %d bit\n", 2447 "NAND bus width %d instead %d bit\n",
2447 (this->options & NAND_BUSWIDTH_16) ? 16 : 8, 2448 (this->options & NAND_BUSWIDTH_16) ? 16 : 8, busw ? 16 : 8);
2448 busw ? 16 : 8);
2449 this->select_chip(mtd, -1); 2449 this->select_chip(mtd, -1);
2450 return 1; 2450 return 1;
2451 } 2451 }
@@ -2456,13 +2456,12 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2456 this->chip_shift = ffs(this->chipsize) - 1; 2456 this->chip_shift = ffs(this->chipsize) - 1;
2457 2457
2458 /* Set the bad block position */ 2458 /* Set the bad block position */
2459 this->badblockpos = mtd->oobblock > 512 ? 2459 this->badblockpos = mtd->oobblock > 512 ? NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2460 NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
2461 2460
2462 /* Get chip options, preserve non chip based options */ 2461 /* Get chip options, preserve non chip based options */
2463 this->options &= ~NAND_CHIPOPTIONS_MSK; 2462 this->options &= ~NAND_CHIPOPTIONS_MSK;
2464 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK; 2463 this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
2465 /* Set this as a default. Board drivers can override it, if neccecary */ 2464 /* Set this as a default. Board drivers can override it, if necessary */
2466 this->options |= NAND_NO_AUTOINCR; 2465 this->options |= NAND_NO_AUTOINCR;
2467 /* Check if this is a not a samsung device. Do not clear the options 2466 /* Check if this is a not a samsung device. Do not clear the options
2468 * for chips which are not having an extended id. 2467 * for chips which are not having an extended id.
@@ -2480,23 +2479,23 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2480 if (mtd->oobblock > 512 && this->cmdfunc == nand_command) 2479 if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
2481 this->cmdfunc = nand_command_lp; 2480 this->cmdfunc = nand_command_lp;
2482 2481
2483 printk (KERN_INFO "NAND device: Manufacturer ID:" 2482 printk(KERN_INFO "NAND device: Manufacturer ID:"
2484 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id, 2483 " 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
2485 nand_manuf_ids[maf_id].name , nand_flash_ids[i].name); 2484 nand_manuf_ids[maf_id].name, nand_flash_ids[i].name);
2486 break; 2485 break;
2487 } 2486 }
2488 2487
2489 if (!nand_flash_ids[i].name) { 2488 if (!nand_flash_ids[i].name) {
2490 printk (KERN_WARNING "No NAND device found!!!\n"); 2489 printk(KERN_WARNING "No NAND device found!!!\n");
2491 this->select_chip(mtd, -1); 2490 this->select_chip(mtd, -1);
2492 return 1; 2491 return 1;
2493 } 2492 }
2494 2493
2495 for (i=1; i < maxchips; i++) { 2494 for (i = 1; i < maxchips; i++) {
2496 this->select_chip(mtd, i); 2495 this->select_chip(mtd, i);
2497 2496
2498 /* Send the command for reading device ID */ 2497 /* Send the command for reading device ID */
2499 this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1); 2498 this->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
2500 2499
2501 /* Read manufacturer and device IDs */ 2500 /* Read manufacturer and device IDs */
2502 if (nand_maf_id != this->read_byte(mtd) || 2501 if (nand_maf_id != this->read_byte(mtd) ||
@@ -2506,13 +2505,13 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2506 if (i > 1) 2505 if (i > 1)
2507 printk(KERN_INFO "%d NAND chips detected\n", i); 2506 printk(KERN_INFO "%d NAND chips detected\n", i);
2508 2507
2509 /* Allocate buffers, if neccecary */ 2508 /* Allocate buffers, if necessary */
2510 if (!this->oob_buf) { 2509 if (!this->oob_buf) {
2511 size_t len; 2510 size_t len;
2512 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift); 2511 len = mtd->oobsize << (this->phys_erase_shift - this->page_shift);
2513 this->oob_buf = kmalloc (len, GFP_KERNEL); 2512 this->oob_buf = kmalloc(len, GFP_KERNEL);
2514 if (!this->oob_buf) { 2513 if (!this->oob_buf) {
2515 printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n"); 2514 printk(KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
2516 return -ENOMEM; 2515 return -ENOMEM;
2517 } 2516 }
2518 this->options |= NAND_OOBBUF_ALLOC; 2517 this->options |= NAND_OOBBUF_ALLOC;
@@ -2521,11 +2520,11 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2521 if (!this->data_buf) { 2520 if (!this->data_buf) {
2522 size_t len; 2521 size_t len;
2523 len = mtd->oobblock + mtd->oobsize; 2522 len = mtd->oobblock + mtd->oobsize;
2524 this->data_buf = kmalloc (len, GFP_KERNEL); 2523 this->data_buf = kmalloc(len, GFP_KERNEL);
2525 if (!this->data_buf) { 2524 if (!this->data_buf) {
2526 if (this->options & NAND_OOBBUF_ALLOC) 2525 if (this->options & NAND_OOBBUF_ALLOC)
2527 kfree (this->oob_buf); 2526 kfree(this->oob_buf);
2528 printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n"); 2527 printk(KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
2529 return -ENOMEM; 2528 return -ENOMEM;
2530 } 2529 }
2531 this->options |= NAND_DATABUF_ALLOC; 2530 this->options |= NAND_DATABUF_ALLOC;
@@ -2555,8 +2554,7 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2555 this->autooob = &nand_oob_64; 2554 this->autooob = &nand_oob_64;
2556 break; 2555 break;
2557 default: 2556 default:
2558 printk (KERN_WARNING "No oob scheme defined for oobsize %d\n", 2557 printk(KERN_WARNING "No oob scheme defined for oobsize %d\n", mtd->oobsize);
2559 mtd->oobsize);
2560 BUG(); 2558 BUG();
2561 } 2559 }
2562 } 2560 }
@@ -2571,7 +2569,7 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2571 * check ECC mode, default to software 2569 * check ECC mode, default to software
2572 * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize 2570 * if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
2573 * fallback to software ECC 2571 * fallback to software ECC
2574 */ 2572 */
2575 this->eccsize = 256; /* set default eccsize */ 2573 this->eccsize = 256; /* set default eccsize */
2576 this->eccbytes = 3; 2574 this->eccbytes = 3;
2577 2575
@@ -2591,19 +2589,19 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2591 case NAND_ECC_HW6_512: 2589 case NAND_ECC_HW6_512:
2592 case NAND_ECC_HW8_512: 2590 case NAND_ECC_HW8_512:
2593 if (mtd->oobblock == 256) { 2591 if (mtd->oobblock == 256) {
2594 printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n"); 2592 printk(KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
2595 this->eccmode = NAND_ECC_SOFT; 2593 this->eccmode = NAND_ECC_SOFT;
2596 this->calculate_ecc = nand_calculate_ecc; 2594 this->calculate_ecc = nand_calculate_ecc;
2597 this->correct_data = nand_correct_data; 2595 this->correct_data = nand_correct_data;
2598 } else 2596 } else
2599 this->eccsize = 512; /* set eccsize to 512 */ 2597 this->eccsize = 512; /* set eccsize to 512 */
2600 break; 2598 break;
2601 2599
2602 case NAND_ECC_HW3_256: 2600 case NAND_ECC_HW3_256:
2603 break; 2601 break;
2604 2602
2605 case NAND_ECC_NONE: 2603 case NAND_ECC_NONE:
2606 printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n"); 2604 printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
2607 this->eccmode = NAND_ECC_NONE; 2605 this->eccmode = NAND_ECC_NONE;
2608 break; 2606 break;
2609 2607
@@ -2613,13 +2611,13 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2613 break; 2611 break;
2614 2612
2615 default: 2613 default:
2616 printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode); 2614 printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
2617 BUG(); 2615 BUG();
2618 } 2616 }
2619 2617
2620 /* Check hardware ecc function availability and adjust number of ecc bytes per 2618 /* Check hardware ecc function availability and adjust number of ecc bytes per
2621 * calculation step 2619 * calculation step
2622 */ 2620 */
2623 switch (this->eccmode) { 2621 switch (this->eccmode) {
2624 case NAND_ECC_HW12_2048: 2622 case NAND_ECC_HW12_2048:
2625 this->eccbytes += 4; 2623 this->eccbytes += 4;
@@ -2631,7 +2629,7 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2631 case NAND_ECC_HW3_256: 2629 case NAND_ECC_HW3_256:
2632 if (this->calculate_ecc && this->correct_data && this->enable_hwecc) 2630 if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
2633 break; 2631 break;
2634 printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n"); 2632 printk(KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
2635 BUG(); 2633 BUG();
2636 } 2634 }
2637 2635
@@ -2659,8 +2657,8 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2659 2657
2660 /* Initialize state, waitqueue and spinlock */ 2658 /* Initialize state, waitqueue and spinlock */
2661 this->state = FL_READY; 2659 this->state = FL_READY;
2662 init_waitqueue_head (&this->wq); 2660 init_waitqueue_head(&this->wq);
2663 spin_lock_init (&this->chip_lock); 2661 spin_lock_init(&this->chip_lock);
2664 2662
2665 /* De-select the device */ 2663 /* De-select the device */
2666 this->select_chip(mtd, -1); 2664 this->select_chip(mtd, -1);
@@ -2695,44 +2693,41 @@ int nand_scan (struct mtd_info *mtd, int maxchips)
2695 /* and make the autooob the default one */ 2693 /* and make the autooob the default one */
2696 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo)); 2694 memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
2697 2695
2698 mtd->owner = THIS_MODULE;
2699
2700 /* Check, if we should skip the bad block table scan */ 2696 /* Check, if we should skip the bad block table scan */
2701 if (this->options & NAND_SKIP_BBTSCAN) 2697 if (this->options & NAND_SKIP_BBTSCAN)
2702 return 0; 2698 return 0;
2703 2699
2704 /* Build bad block table */ 2700 /* Build bad block table */
2705 return this->scan_bbt (mtd); 2701 return this->scan_bbt(mtd);
2706} 2702}
2707 2703
2708/** 2704/**
2709 * nand_release - [NAND Interface] Free resources held by the NAND device 2705 * nand_release - [NAND Interface] Free resources held by the NAND device
2710 * @mtd: MTD device structure 2706 * @mtd: MTD device structure
2711*/ 2707*/
2712void nand_release (struct mtd_info *mtd) 2708void nand_release(struct mtd_info *mtd)
2713{ 2709{
2714 struct nand_chip *this = mtd->priv; 2710 struct nand_chip *this = mtd->priv;
2715 2711
2716#ifdef CONFIG_MTD_PARTITIONS 2712#ifdef CONFIG_MTD_PARTITIONS
2717 /* Deregister partitions */ 2713 /* Deregister partitions */
2718 del_mtd_partitions (mtd); 2714 del_mtd_partitions(mtd);
2719#endif 2715#endif
2720 /* Deregister the device */ 2716 /* Deregister the device */
2721 del_mtd_device (mtd); 2717 del_mtd_device(mtd);
2722 2718
2723 /* Free bad block table memory */ 2719 /* Free bad block table memory */
2724 kfree (this->bbt); 2720 kfree(this->bbt);
2725 /* Buffer allocated by nand_scan ? */ 2721 /* Buffer allocated by nand_scan ? */
2726 if (this->options & NAND_OOBBUF_ALLOC) 2722 if (this->options & NAND_OOBBUF_ALLOC)
2727 kfree (this->oob_buf); 2723 kfree(this->oob_buf);
2728 /* Buffer allocated by nand_scan ? */ 2724 /* Buffer allocated by nand_scan ? */
2729 if (this->options & NAND_DATABUF_ALLOC) 2725 if (this->options & NAND_DATABUF_ALLOC)
2730 kfree (this->data_buf); 2726 kfree(this->data_buf);
2731} 2727}
2732 2728
2733EXPORT_SYMBOL_GPL (nand_scan); 2729EXPORT_SYMBOL_GPL(nand_scan);
2734EXPORT_SYMBOL_GPL (nand_release); 2730EXPORT_SYMBOL_GPL(nand_release);
2735
2736 2731
2737static int __init nand_base_init(void) 2732static int __init nand_base_init(void)
2738{ 2733{
@@ -2748,6 +2743,6 @@ static void __exit nand_base_exit(void)
2748module_init(nand_base_init); 2743module_init(nand_base_init);
2749module_exit(nand_base_exit); 2744module_exit(nand_base_exit);
2750 2745
2751MODULE_LICENSE ("GPL"); 2746MODULE_LICENSE("GPL");
2752MODULE_AUTHOR ("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>"); 2747MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
2753MODULE_DESCRIPTION ("Generic NAND flash driver code"); 2748MODULE_DESCRIPTION("Generic NAND flash driver code");
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-20 14:30:15 -0500