开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
nand.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：34k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

nand.c：源码内容
  1. /*
  2.  *  drivers/mtd/nand.c
  3.  *
  4.  *  Copyright (C) 2000 Steven J. Hill (sjhill@cotw.com)
  5.  *
  6.  * $Id: nand.c,v 1.12 2001/10/02 15:05:14 dwmw2 Exp $
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License version 2 as
  10.  * published by the Free Software Foundation.
  11.  *
  12.  *  Overview:
  13.  *   This is the generic MTD driver for NAND flash devices. It should be
  14.  *   capable of working with almost all NAND chips currently available.
  15.  */
  17. #include <linux/delay.h>
  18. #include <linux/errno.h>
  19. #include <linux/sched.h>
  20. #include <linux/types.h>
  21. #include <linux/mtd/mtd.h>
  22. #include <linux/mtd/nand.h>
  23. #include <linux/mtd/nand_ids.h>
  24. #include <linux/interrupt.h>
  25. #include <asm/io.h>
  27. #ifdef CONFIG_MTD_NAND_ECC
  28. #include <linux/mtd/nand_ecc.h>
  29. #endif
  31. /*
  32.  * Macros for low-level register control
  33.  */
  34. #define NAND_CTRL (*(volatile unsigned char *) 
  35. ((struct nand_chip *) mtd->priv)->CTRL_ADDR)
  36. #define nand_select() NAND_CTRL &= ~this->NCE; 
  37. nand_command(mtd, NAND_CMD_RESET, -1, -1); 
  38. udelay (10);
  39. #define nand_deselect() NAND_CTRL |= ~this->NCE;
  41. /*
  42.  * NAND low-level MTD interface functions
  43.  */
  44. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
  45. size_t *retlen, u_char *buf);
  46. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  47. size_t *retlen, u_char *buf, u_char *ecc_code);
  48. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
  49. size_t *retlen, u_char *buf);
  50. static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
  51. size_t *retlen, const u_char *buf);
  52. static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
  53. size_t *retlen, const u_char *buf,
  54. u_char *ecc_code);
  55. static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
  56. size_t *retlen, const u_char *buf);
  57. static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
  58. unsigned long count, loff_t to, size_t *retlen);
  59. static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
  60. static void nand_sync (struct mtd_info *mtd);
  62. /*
  63.  * Send command to NAND device
  64.  */
  65. static void nand_command (struct mtd_info *mtd, unsigned command,
  66. int column, int page_addr)
  67. {
  68. register struct nand_chip *this = mtd->priv;
  69. register unsigned long NAND_IO_ADDR = this->IO_ADDR;
  71. /* Begin command latch cycle */
  72. NAND_CTRL |= this->CLE;
  74. /*
  75.  * Write out the command to the device.
  76.  */
  77. if (command != NAND_CMD_SEQIN)
  78. writeb (command, NAND_IO_ADDR);
  79. else {
  80. if (mtd->oobblock == 256 && column >= 256) {
  81. column -= 256;
  82. writeb(NAND_CMD_RESET, NAND_IO_ADDR);
  83. writeb(NAND_CMD_READOOB, NAND_IO_ADDR);
  84. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  85. }
  86. else if (mtd->oobblock == 512 && column >= 256) {
  87. if (column < 512) {
  88. column -= 256;
  89. writeb(NAND_CMD_READ1, NAND_IO_ADDR);
  90. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  91. }
  92. else {
  93. column -= 512;
  94. writeb(NAND_CMD_READOOB, NAND_IO_ADDR);
  95. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  96. }
  97. }
  98. else {
  99. writeb(NAND_CMD_READ0, NAND_IO_ADDR);
  100. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  101. }
  102. }
  104. /* Set ALE and clear CLE to start address cycle */
  105. NAND_CTRL &= ~this->CLE;
  106. NAND_CTRL |= this->ALE;
  108. /* Serially input address */
  109. if (column != -1)
  110. writeb (column, NAND_IO_ADDR);
  111. if (page_addr != -1) {
  112. writeb ((unsigned char) (page_addr & 0xff), NAND_IO_ADDR);
  113. writeb ((unsigned char) ((page_addr >> 8) & 0xff), NAND_IO_ADDR);
  114. /* One more address cycle for higher density devices */
  115. if (mtd->size & 0x0c000000) {
  116. writeb ((unsigned char) ((page_addr >> 16) & 0x0f),
  117. NAND_IO_ADDR);
  118. }
  119. }
  121. /* Latch in address */
  122. NAND_CTRL &= ~this->ALE;
  124. /* Pause for 15us */
  125. udelay (15);
  126. }
  128. /*
  129.  * NAND read
  130.  */
  131. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
  132. size_t *retlen, u_char *buf)
  133. {
  134. #ifdef CONFIG_MTD_NAND_ECC
  135. struct nand_chip *this = mtd->priv;
  137. return nand_read_ecc (mtd, from, len, retlen, buf, this->ecc_code_buf);
  138. #else
  139. return nand_read_ecc (mtd, from, len, retlen, buf, NULL);
  140. #endif
  141. }
  143. /*
  144.  * NAND read with ECC
  145.  */
  146. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  147. size_t *retlen, u_char *buf, u_char *ecc_code)
  148. {
  149. int j, col, page, state;
  150. int erase_state = 0;
  151. struct nand_chip *this = mtd->priv;
  152. DECLARE_WAITQUEUE(wait, current);
  153. #ifdef CONFIG_MTD_NAND_ECC
  154. int ecc_result;
  155. u_char ecc_calc[6];
  156. #endif
  158. DEBUG (MTD_DEBUG_LEVEL3,
  159. "nand_read_ecc: from = 0x%08x, len = %in", (unsigned int) from,
  160. (int) len);
  162. /* Do not allow reads past end of device */
  163. if ((from + len) > mtd->size) {
  164. DEBUG (MTD_DEBUG_LEVEL0,
  165. "nand_read_ecc: Attempt read beyond end of devicen");
  166. *retlen = 0;
  167. return -EINVAL;
  168. }
  170. /* Grab the lock and see if the device is available */
  171. retry:
  172. spin_lock_bh (&this->chip_lock);
  174. switch (this->state) {
  175. case FL_READY:
  176. this->state = FL_READING;
  177. spin_unlock_bh (&this->chip_lock);
  178. break;
  180. case FL_ERASING:
  181. this->state = FL_READING;
  182. erase_state = 1;
  183. spin_unlock_bh (&this->chip_lock);
  184. break;
  186. default:
  187. set_current_state (TASK_UNINTERRUPTIBLE);
  188. add_wait_queue (&this->wq, &wait);
  189. spin_unlock_bh (&this->chip_lock);
  190. schedule();
  192. remove_wait_queue (&this->wq, &wait);
  193. goto retry;
  194. };
  196. /* First we calculate the starting page */
  197. page = from >> this->page_shift;
  199. /* Get raw starting column */
  200. col = from & (mtd->oobblock - 1);
  202. /* State machine for devices having pages larger than 256 bytes */
  203. state = (col < mtd->eccsize) ? 0 : 1;
  205. /* Calculate column address within ECC block context */
  206. col = (col >= mtd->eccsize) ? (col - mtd->eccsize) : col;
  208. /* Initialize return value */
  209. *retlen = 0;
  211. /* Select the NAND device */
  212. nand_select ();
  214. /* Loop until all data read */
  215. while (*retlen < len) {
  217. #ifdef CONFIG_MTD_NAND_ECC
  218. /* Send the read command */
  219. if (!state)
  220. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  221. else 
  222. nand_command (mtd, NAND_CMD_READ1, 0x00, page);
  224. /* Read in a block big enough for ECC */
  225. for (j=0 ; j < mtd->eccsize ; j++)
  226. this->data_buf[j] = readb (this->IO_ADDR);
  228. /* Read in the out-of-band data */
  229. if (!state) {
  230. nand_command (mtd, NAND_CMD_READOOB, 0x00, page);
  231. for (j=0 ; j<3 ; j++)
  232. ecc_code[j] = readb(this->IO_ADDR);
  233. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  234. }
  235. else {
  236. nand_command (mtd, NAND_CMD_READOOB, 0x03, page);
  237. for (j=3 ; j<6 ; j++)
  238. ecc_code[j] = readb(this->IO_ADDR);
  239. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  240. }
  242. /* Calculate the ECC and verify it */
  243. if (!state) {
  244. nand_calculate_ecc (&this->data_buf[0],
  245. &ecc_calc[0]);
  246. ecc_result = nand_correct_data (&this->data_buf[0],
  247. &ecc_code[0], &ecc_calc[0]);
  248. }
  249. else {
  250. nand_calculate_ecc (&this->data_buf[0],
  251. &ecc_calc[3]);
  252. ecc_result = nand_correct_data (&this->data_buf[0],
  253. &ecc_code[3], &ecc_calc[3]);
  254. }
  255. if (ecc_result == -1) {
  256. DEBUG (MTD_DEBUG_LEVEL0,
  257. "nand_read_ecc: " 
  258. "Failed ECC read, page 0x%08xn", page);
  259. nand_deselect ();
  260. spin_lock_bh (&this->chip_lock);
  261. if (erase_state)
  262. this->state = FL_ERASING;
  263. else
  264. this->state = FL_READY;
  265. wake_up (&this->wq);
  266. spin_unlock_bh (&this->chip_lock);
  267. return -EIO;
  268. }
  270. /* Read the data from ECC data buffer into return buffer */
  271. if ((*retlen + (mtd->eccsize - col)) >= len) {
  272. while (*retlen < len)
  273. buf[(*retlen)++] = this->data_buf[col++];
  274. /* We're done */
  275. continue;
  276. }
  277. else
  278. for (j=col ; j < mtd->eccsize ; j++)
  279. buf[(*retlen)++] = this->data_buf[j];
  280. #else
  281. /* Send the read command */
  282. if (!state)
  283. nand_command (mtd, NAND_CMD_READ0, col, page);
  284. else 
  285. nand_command (mtd, NAND_CMD_READ1, col, page);
  287. /* Read the data directly into the return buffer */ 
  288. if ((*retlen + (mtd->eccsize - col)) >= len) {
  289. while (*retlen < len)
  290. buf[(*retlen)++] = readb (this->IO_ADDR);
  291. /* We're done */
  292. continue;
  293. }
  294. else
  295. for (j=col ; j < mtd->eccsize ; j++)
  296. buf[(*retlen)++] = readb (this->IO_ADDR);
  297. #endif
  299. /*
  300.  * If the amount of data to be read is greater than
  301.  * (256 - col), then all subsequent reads will take
  302.  * place on page or half-page (in the case of 512 byte
  303.  * page devices) aligned boundaries and the column
  304.  * address will be zero. Setting the column address to
  305.  * to zero after the first read allows us to simplify
  306.  * the reading of data and the if/else statements above.
  307.  */
  308. if (col)
  309. col = 0x00;
  311. /* Increment page address */
  312. if ((mtd->oobblock == 256) || state)
  313. page++;
  315. /* Toggle state machine */
  316. if (mtd->oobblock == 512)
  317. state = state ? 0 : 1;
  318. }
  320. /* De-select the NAND device */
  321. nand_deselect ();
  323. /* Wake up anyone waiting on the device */
  324. spin_lock_bh (&this->chip_lock);
  325. if (erase_state)
  326. this->state = FL_ERASING;
  327. else
  328. this->state = FL_READY;
  329. wake_up (&this->wq);
  330. spin_unlock_bh (&this->chip_lock);
  332. /* Return happy */
  333. return 0;
  334. }
  336. /*
  337.  * NAND read out-of-band
  338.  */
  339. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
  340. size_t *retlen, u_char *buf)
  341. {
  342. int i, col, page;
  343. int erase_state = 0;
  344. struct nand_chip *this = mtd->priv;
  345. DECLARE_WAITQUEUE(wait, current);
  347. DEBUG (MTD_DEBUG_LEVEL3,
  348. "nand_read_oob: from = 0x%08x, len = %in", (unsigned int) from,
  349. (int) len);
  351. /* Shift to get page */
  352. page = ((int) from) >> this->page_shift;
  354. /* Mask to get column */
  355. col = from & 0x0f;
  357. /* Initialize return length value */
  358. *retlen = 0;
  360. /* Do not allow read past end of page */
  361. if ((col + len) > mtd->oobsize) {
  362. DEBUG (MTD_DEBUG_LEVEL0,
  363. "nand_read_oob: Attempt read past end of page " 
  364. "0x%08x, column %i, length %in", page, col, len);
  365. return -EINVAL;
  366. }
  368. retry:
  369. /* Grab the lock and see if the device is available */
  370. spin_lock_bh (&this->chip_lock);
  372. switch (this->state) {
  373. case FL_READY:
  374. this->state = FL_READING;
  375. spin_unlock_bh (&this->chip_lock);
  376. break;
  378. case FL_ERASING:
  379. this->state = FL_READING;
  380. erase_state = 1;
  381. spin_unlock_bh (&this->chip_lock);
  382. break;
  384. default:
  385. set_current_state (TASK_UNINTERRUPTIBLE);
  386. add_wait_queue (&this->wq, &wait);
  387. spin_unlock_bh (&this->chip_lock);
  388. schedule();
  390. remove_wait_queue (&this->wq, &wait);
  391. goto retry;
  392. };
  394. /* Select the NAND device */
  395. nand_select ();
  397. /* Send the read command */
  398. nand_command (mtd, NAND_CMD_READOOB, col, page);
  400. /* Read the data */
  401. for (i = 0 ; i < len ; i++)
  402. buf[i] = readb (this->IO_ADDR);
  404. /* De-select the NAND device */
  405. nand_deselect ();
  407. /* Wake up anyone waiting on the device */
  408. spin_lock_bh (&this->chip_lock);
  409. if (erase_state)
  410. this->state = FL_ERASING;
  411. else
  412. this->state = FL_READY;
  413. wake_up (&this->wq);
  414. spin_unlock_bh (&this->chip_lock);
  416. /* Return happy */
  417. *retlen = len;
  418. return 0;
  419. }
  421. /*
  422.  * NAND write
  423.  */
  424. static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
  425. size_t *retlen, const u_char *buf)
  426. {
  427. #ifdef CONFIG_MTD_NAND_ECC
  428. struct nand_chip *this = mtd->priv;
  430. return nand_write_ecc (mtd, to, len, retlen, buf, this->ecc_code_buf);
  431. #else
  432. return nand_write_ecc (mtd, to, len, retlen, buf, NULL);
  433. #endif
  434. }
  436. /*
  437.  * NAND write with ECC
  438.  */
  439. static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
  440. size_t *retlen, const u_char *buf,
  441. u_char *ecc_code)
  442. {
  443. int i, page, col, cnt, status;
  444. struct nand_chip *this = mtd->priv;
  445. DECLARE_WAITQUEUE(wait, current);
  446. #ifdef CONFIG_MTD_NAND_ECC
  447. int ecc_bytes = (mtd->oobblock == 512) ? 6 : 3;
  448. #endif
  450. DEBUG (MTD_DEBUG_LEVEL3,
  451. "nand_write_ecc: to = 0x%08x, len = %in", (unsigned int) to,
  452. (int) len);
  454. /* Do not allow write past end of page */
  455. if ((to + len) > mtd->size) {
  456. DEBUG (MTD_DEBUG_LEVEL0,
  457. "nand_write_ecc: Attempted write past end of devicen");
  458. return -EINVAL;
  459. }
  461. retry:
  462. /* Grab the lock and see if the device is available */
  463. spin_lock_bh (&this->chip_lock);
  465. switch (this->state) {
  466. case FL_READY:
  467. this->state = FL_WRITING;
  468. spin_unlock_bh (&this->chip_lock);
  469. break;
  471. default:
  472. set_current_state (TASK_UNINTERRUPTIBLE);
  473. add_wait_queue (&this->wq, &wait);
  474. spin_unlock_bh (&this->chip_lock);
  475. schedule();
  477. remove_wait_queue (&this->wq, &wait);
  478. goto retry;
  479. };
  481. /* Shift to get page */
  482. page = ((int) to) >> this->page_shift;
  484. /* Get the starting column */
  485. col = to & (mtd->oobblock - 1);
  487. /* Initialize return length value */
  488. *retlen = 0;
  490. /* Select the NAND device */
  491. nand_select ();
  493. /* Check the WP bit */
  494. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  495. if (!(readb (this->IO_ADDR) & 0x80)) {
  496. DEBUG (MTD_DEBUG_LEVEL0,
  497. "nand_write_ecc: Device is write protected!!!n");
  498. nand_deselect ();
  499. spin_lock_bh (&this->chip_lock);
  500. this->state = FL_READY;
  501. wake_up (&this->wq);
  502. spin_unlock_bh (&this->chip_lock);
  503. return -EIO;
  504. }
  506. /* Loop until all data is written */
  507. while (*retlen < len) {
  508. /* Write data into buffer */
  509. if ((col + len) >= mtd->oobblock)
  510. for(i=col, cnt=0 ; i < mtd->oobblock ; i++, cnt++)
  511. this->data_buf[i] = buf[(*retlen + cnt)];
  512. else
  513. for(i=col, cnt=0 ; cnt < (len - *retlen) ; i++, cnt++)
  514. this->data_buf[i] = buf[(*retlen + cnt)];
  516. #ifdef CONFIG_MTD_NAND_ECC
  517. /* Zero out the ECC array */
  518. for (i=0 ; i < 6 ; i++)
  519. ecc_code[i] = 0x00;
  521. /* Calculate and write the ECC if we have enough data */
  522. if ((col < mtd->eccsize) &&
  523. ((col + (len - *retlen)) >= mtd->eccsize)) {
  524. nand_command (mtd, NAND_CMD_READ0, col, page);
  525. for (i=0 ; i < col ; i++)
  526. this->data_buf[i] = readb (this->IO_ADDR); 
  527. nand_calculate_ecc (&this->data_buf[0], &ecc_code[0]);
  528. for (i=0 ; i<3 ; i++)
  529. this->data_buf[(mtd->oobblock + i)] =
  530. ecc_code[i];
  531. }
  533. /* Calculate and write the second ECC if we have enough data */
  534. if ((mtd->oobblock == 512) &&
  535. ((col + (len - *retlen)) >= mtd->oobblock)) {
  536. nand_calculate_ecc (&this->data_buf[256], &ecc_code[3]);
  537. for (i=3 ; i<6 ; i++)
  538. this->data_buf[(mtd->oobblock + i)] =
  539. ecc_code[i];
  540. }
  542. /* Write ones for partial page programming */
  543. for (i=ecc_bytes ; i < mtd->oobsize ; i++)
  544. this->data_buf[(mtd->oobblock + i)] = 0xff;
  545. #else
  546. /* Write ones for partial page programming */
  547. for (i=mtd->oobblock ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  548. this->data_buf[i] = 0xff;
  549. #endif
  551. /* Write pre-padding bytes into buffer */
  552. for (i=0 ; i < col ; i++)
  553. this->data_buf[i] = 0xff;
  555. /* Write post-padding bytes into buffer */
  556. if ((col + (len - *retlen)) < mtd->oobblock) {
  557. for(i=(col + cnt) ; i < mtd->oobblock ; i++)
  558. this->data_buf[i] = 0xff;
  559. }
  561. /* Send command to begin auto page programming */
  562. nand_command (mtd, NAND_CMD_SEQIN, 0x00, page);
  564. /* Write out complete page of data */
  565. for (i=0 ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  566. writeb (this->data_buf[i], this->IO_ADDR);
  568. /* Send command to actually program the data */
  569. nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  571. /*
  572.  * Wait for program operation to complete. This could
  573.  * take up to 3000us (3ms) on some devices, so we try
  574.  * and exit as quickly as possible.
  575.  */
  576. status = 0;
  577. for (i=0 ; i<24 ; i++) {
  578. /* Delay for 125us */
  579. udelay (125);
  581. /* Check the status */
  582. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  583. status = (int) readb (this->IO_ADDR);
  584. if (status & 0x40)
  585. break;
  586. }
  588. /* See if device thinks it succeeded */
  589. if (status & 0x01) {
  590. DEBUG (MTD_DEBUG_LEVEL0,
  591. "nand_write_ecc: " 
  592. "Failed write, page 0x%08x, " 
  593. "%6i bytes were succesfuln", page, *retlen);
  594. nand_deselect ();
  595. spin_lock_bh (&this->chip_lock);
  596. this->state = FL_READY;
  597. wake_up (&this->wq);
  598. spin_unlock_bh (&this->chip_lock);
  599. return -EIO;
  600. }
  602. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  603. /*
  604.  * The NAND device assumes that it is always writing to
  605.  * a cleanly erased page. Hence, it performs its internal
  606.  * write verification only on bits that transitioned from
  607.  * 1 to 0. The device does NOT verify the whole page on a
  608.  * byte by byte basis. It is possible that the page was
  609.  * not completely erased or the page is becoming unusable
  610.  * due to wear. The read with ECC would catch the error
  611.  * later when the ECC page check fails, but we would rather
  612.  * catch it early in the page write stage. Better to write
  613.  * no data than invalid data.
  614.  */
  616. /* Send command to read back the page */
  617. if (col < mtd->eccsize)
  618. nand_command (mtd, NAND_CMD_READ0, col, page);
  619. else
  620. nand_command (mtd, NAND_CMD_READ1, col - 256, page);
  622. /* Loop through and verify the data */
  623. for (i=col ; i < cnt ; i++) {
  624. if (this->data_buf[i] != readb (this->IO_ADDR)) {
  625. DEBUG (MTD_DEBUG_LEVEL0,
  626. "nand_write_ecc: " 
  627. "Failed write verify, page 0x%08x, " 
  628. "%6i bytes were succesfuln",
  629. page, *retlen);
  630. nand_deselect ();
  631. spin_lock_bh (&this->chip_lock);
  632. this->state = FL_READY;
  633. wake_up (&this->wq);
  634. spin_unlock_bh (&this->chip_lock);
  635. return -EIO;
  636. }
  637. }
  639. #ifdef CONFIG_MTD_NAND_ECC
  640. /*
  641.  * We also want to check that the ECC bytes wrote
  642.  * correctly for the same reasons stated above.
  643.  */
  644. nand_command (mtd, NAND_CMD_READOOB, 0x00, page);
  645. for (i=0 ; i < ecc_bytes ; i++) {
  646. if ((readb (this->IO_ADDR) != ecc_code[i]) &&
  647. ecc_code[i]) {
  648. DEBUG (MTD_DEBUG_LEVEL0,
  649. "nand_write_ecc: Failed ECC write " 
  650. "verify, page 0x%08x, " 
  651. "%6i bytes were succesfuln",
  652. page, i);
  653. nand_deselect ();
  654. spin_lock_bh (&this->chip_lock);
  655. this->state = FL_READY;
  656. wake_up (&this->wq);
  657. spin_unlock_bh (&this->chip_lock);
  658. return -EIO;
  659. }
  660. }
  661. #endif
  663. #endif
  665. /*
  666.  * If we are writing a large amount of data and/or it
  667.  * crosses page or half-page boundaries, we set the
  668.  * the column to zero. It simplifies the program logic.
  669.  */
  670. if (col)
  671. col = 0x00;
  673. /* Update written bytes count */
  674. *retlen += cnt;
  676. /* Increment page address */
  677. page++;
  678. }
  680. /* De-select the NAND device */
  681. nand_deselect ();
  683. /* Wake up anyone waiting on the device */
  684. spin_lock_bh (&this->chip_lock);
  685. this->state = FL_READY;
  686. wake_up (&this->wq);
  687. spin_unlock_bh (&this->chip_lock);
  689. /* Return happy */
  690. *retlen = len;
  691. return 0;
  692. }
  694. /*
  695.  * NAND write out-of-band
  696.  */
  697. static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
  698. size_t *retlen, const u_char *buf)
  699. {
  700. int i, column, page, status;
  701. struct nand_chip *this = mtd->priv;
  702. DECLARE_WAITQUEUE(wait, current);
  704. DEBUG (MTD_DEBUG_LEVEL3,
  705. "nand_write_oob: to = 0x%08x, len = %in", (unsigned int) to,
  706. (int) len);
  708. /* Shift to get page */
  709. page = ((int) to) >> this->page_shift;
  711. /* Mask to get column */
  712. column = to & 0x1f;
  714. /* Initialize return length value */
  715. *retlen = 0;
  717. /* Do not allow write past end of page */
  718. if ((column + len) > mtd->oobsize) {
  719. DEBUG (MTD_DEBUG_LEVEL0,
  720. "nand_write_oob: Attempt to write past end of pagen");
  721. return -EINVAL;
  722. }
  724. retry:
  725. /* Grab the lock and see if the device is available */
  726. spin_lock_bh (&this->chip_lock);
  728. switch (this->state) {
  729. case FL_READY:
  730. this->state = FL_WRITING;
  731. spin_unlock_bh (&this->chip_lock);
  732. break;
  734. default:
  735. set_current_state (TASK_UNINTERRUPTIBLE);
  736. add_wait_queue (&this->wq, &wait);
  737. spin_unlock_bh (&this->chip_lock);
  738. schedule();
  740. remove_wait_queue (&this->wq, &wait);
  741. goto retry;
  742. };
  744. /* Select the NAND device */
  745. nand_select ();
  747. /* Check the WP bit */
  748. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  749. if (!(readb (this->IO_ADDR) & 0x80)) {
  750. DEBUG (MTD_DEBUG_LEVEL0,
  751. "nand_write_oob: Device is write protected!!!n");
  752. nand_deselect ();
  753. spin_lock_bh (&this->chip_lock);
  754. this->state = FL_READY;
  755. wake_up (&this->wq);
  756. spin_unlock_bh (&this->chip_lock);
  757. return -EIO;
  758. }
  760. /* Write out desired data */
  761. nand_command (mtd, NAND_CMD_SEQIN, column + 512, page);
  762. for (i=0 ; i<len ; i++)
  763. writeb (buf[i], this->IO_ADDR);
  765. /* Send command to program the OOB data */
  766. nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  768. /*
  769.  * Wait for program operation to complete. This could
  770.  * take up to 3000us (3ms) on some devices, so we try
  771.  * and exit as quickly as possible.
  772.  */
  773. status = 0;
  774. for (i=0 ; i<24 ; i++) {
  775. /* Delay for 125us */
  776. udelay (125);
  778. /* Check the status */
  779. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  780. status = (int) readb (this->IO_ADDR);
  781. if (status & 0x40)
  782. break;
  783. }
  785. /* See if device thinks it succeeded */
  786. if (status & 0x01) {
  787. DEBUG (MTD_DEBUG_LEVEL0,
  788. "nand_write_oob: " 
  789. "Failed write, page 0x%08xn", page);
  790. nand_deselect ();
  791. spin_lock_bh (&this->chip_lock);
  792. this->state = FL_READY;
  793. wake_up (&this->wq);
  794. spin_unlock_bh (&this->chip_lock);
  795. return -EIO;
  796. }
  798. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  799. /* Send command to read back the data */
  800. nand_command (mtd, NAND_CMD_READOOB, column, page);
  802. /* Loop through and verify the data */
  803. for (i=0 ; i<len ; i++) {
  804. if (buf[i] != readb (this->IO_ADDR)) {
  805. DEBUG (MTD_DEBUG_LEVEL0,
  806. "nand_write_oob: " 
  807. "Failed write verify, page 0x%08xn", page);
  808. nand_deselect ();
  809. spin_lock_bh (&this->chip_lock);
  810. this->state = FL_READY;
  811. wake_up (&this->wq);
  812. spin_unlock_bh (&this->chip_lock);
  813. return -EIO;
  814. }
  815. }
  816. #endif
  818. /* De-select the NAND device */
  819. nand_deselect ();
  821. /* Wake up anyone waiting on the device */
  822. spin_lock_bh (&this->chip_lock);
  823. this->state = FL_READY;
  824. wake_up (&this->wq);
  825. spin_unlock_bh (&this->chip_lock);
  827. /* Return happy */
  828. *retlen = len;
  829. return 0;
  830. }
  832. /*
  833.  * NAND write with iovec
  834.  */
  835. static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
  836. unsigned long count, loff_t to, size_t *retlen)
  837. {
  838. int i, page, col, cnt, len, total_len, status;
  839. struct nand_chip *this = mtd->priv;
  840. DECLARE_WAITQUEUE(wait, current);
  841. #ifdef CONFIG_MTD_NAND_ECC
  842. int ecc_bytes = (mtd->oobblock == 512) ? 6 : 3;
  843. #endif
  845. /* Calculate total length of data */
  846. total_len = 0;
  847. for (i=0 ; i < count ; i++)
  848. total_len += (int) vecs[i].iov_len;
  850. DEBUG (MTD_DEBUG_LEVEL3,
  851. "nand_writev: to = 0x%08x, len = %in", (unsigned int) to,
  852. (unsigned int) total_len);
  854. /* Do not allow write past end of page */
  855. if ((to + total_len) > mtd->size) {
  856. DEBUG (MTD_DEBUG_LEVEL0,
  857. "nand_writev: Attempted write past end of devicen");
  858. return -EINVAL;
  859. }
  861. retry:
  862. /* Grab the lock and see if the device is available */
  863. spin_lock_bh (&this->chip_lock);
  865. switch (this->state) {
  866. case FL_READY:
  867. this->state = FL_WRITING;
  868. spin_unlock_bh (&this->chip_lock);
  869. break;
  871. default:
  872. set_current_state (TASK_UNINTERRUPTIBLE);
  873. add_wait_queue (&this->wq, &wait);
  874. spin_unlock_bh (&this->chip_lock);
  875. schedule();
  877. remove_wait_queue (&this->wq, &wait);
  878. goto retry;
  879. };
  881. /* Shift to get page */
  882. page = ((int) to) >> this->page_shift;
  884. /* Get the starting column */
  885. col = to & (mtd->oobblock - 1);
  887. /* Initialize return length value */
  888. *retlen = 0;
  890. /* Select the NAND device */
  891. nand_select ();
  893. /* Check the WP bit */
  894. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  895. if (!(readb (this->IO_ADDR) & 0x80)) {
  896. DEBUG (MTD_DEBUG_LEVEL0,
  897. "nand_writev: Device is write protected!!!n");
  898. nand_deselect ();
  899. spin_lock_bh (&this->chip_lock);
  900. this->state = FL_READY;
  901. wake_up (&this->wq);
  902. spin_unlock_bh (&this->chip_lock);
  903. return -EIO;
  904. }
  906. /* Loop until all iovecs' data has been written */
  907. cnt = col;
  908. len = 0;
  909. while (count) {
  910. /* Do any need pre-fill for partial page programming */
  911. for (i=0 ; i < cnt ; i++)
  912. this->data_buf[i] = 0xff;
  914. /*
  915.  * Read data out of each tuple until we have a full page
  916.  * to write or we've read all the tuples.
  917.  */
  918. while ((cnt < mtd->oobblock) && count) {
  919. this->data_buf[cnt++] =
  920. ((u_char *) vecs->iov_base)[len++];
  921. if (len >= (int) vecs->iov_len) {
  922. vecs++;
  923. len = 0;
  924. count--;
  925. }
  926. }
  928. /* Do any need post-fill for partial page programming */
  929. for (i=cnt ; i < mtd->oobblock ; i++)
  930. this->data_buf[i] = 0xff;
  932. #ifdef CONFIG_MTD_NAND_ECC
  933. /* Zero out the ECC array */
  934. for (i=0 ; i < 6 ; i++)
  935. this->ecc_code_buf[i] = 0x00;
  937. /* Calculate and write the first ECC */
  938. if (col >= mtd->eccsize) {
  939. nand_command (mtd, NAND_CMD_READ0, col, page);
  940. for (i=0 ; i < col ; i++)
  941. this->data_buf[i] = readb (this->IO_ADDR); 
  942. nand_calculate_ecc (&this->data_buf[0],
  943. &(this->ecc_code_buf[0]));
  944. for (i=0 ; i<3 ; i++)
  945. this->data_buf[(mtd->oobblock + i)] =
  946. this->ecc_code_buf[i];
  947. }
  949. /* Calculate and write the second ECC */
  950. if ((mtd->oobblock == 512) && (cnt == mtd->oobblock)) {
  951. nand_calculate_ecc (&this->data_buf[256],
  952. &(this->ecc_code_buf[3]));
  953. for (i=3 ; i<6 ; i++)
  954. this->data_buf[(mtd->oobblock + i)] =
  955. this->ecc_code_buf[i];
  956. }
  958. /* Write ones for partial page programming */
  959. for (i=ecc_bytes ; i < mtd->oobsize ; i++)
  960. this->data_buf[(mtd->oobblock + i)] = 0xff;
  961. #else
  962. /* Write ones for partial page programming */
  963. for (i=mtd->oobblock ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  964. this->data_buf[i] = 0xff;
  965. #endif
  966. /* Send command to begin auto page programming */
  967. nand_command (mtd, NAND_CMD_SEQIN, 0x00, page);
  969. /* Write out complete page of data */
  970. for (i=0 ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  971. writeb (this->data_buf[i], this->IO_ADDR);
  973. /* Send command to actually program the data */
  974. nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  976. /*
  977.  * Wait for program operation to complete. This could
  978.  * take up to 3000us (3ms) on some devices, so we try
  979.  * and exit as quickly as possible.
  980.  */
  981. status = 0;
  982. for (i=0 ; i<24 ; i++) {
  983. /* Delay for 125us */
  984. udelay (125);
  986. /* Check the status */
  987. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  988. status = (int) readb (this->IO_ADDR);
  989. if (status & 0x40)
  990. break;
  991. }
  993. /* See if device thinks it succeeded */
  994. if (status & 0x01) {
  995. DEBUG (MTD_DEBUG_LEVEL0,
  996. "nand_writev: " 
  997. "Failed write, page 0x%08x, " 
  998. "%6i bytes were succesfuln", page, *retlen);
  999. nand_deselect ();
  1000. spin_lock_bh (&this->chip_lock);
  1001. this->state = FL_READY;
  1002. wake_up (&this->wq);
  1003. spin_unlock_bh (&this->chip_lock);
  1004. return -EIO;
  1005. }
  1007. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  1008. /*
  1009.  * The NAND device assumes that it is always writing to
  1010.  * a cleanly erased page. Hence, it performs its internal
  1011.  * write verification only on bits that transitioned from
  1012.  * 1 to 0. The device does NOT verify the whole page on a
  1013.  * byte by byte basis. It is possible that the page was
  1014.  * not completely erased or the page is becoming unusable
  1015.  * due to wear. The read with ECC would catch the error
  1016.  * later when the ECC page check fails, but we would rather
  1017.  * catch it early in the page write stage. Better to write
  1018.  * no data than invalid data.
  1019.  */
  1021. /* Send command to read back the page */
  1022. if (col < mtd->eccsize)
  1023. nand_command (mtd, NAND_CMD_READ0, col, page);
  1024. else
  1025. nand_command (mtd, NAND_CMD_READ1, col - 256, page);
  1027. /* Loop through and verify the data */
  1028. for (i=col ; i < cnt ; i++) {
  1029. if (this->data_buf[i] != readb (this->IO_ADDR)) {
  1030. DEBUG (MTD_DEBUG_LEVEL0,
  1031. "nand_writev: " 
  1032. "Failed write verify, page 0x%08x, " 
  1033. "%6i bytes were succesfuln",
  1034. page, *retlen);
  1035. nand_deselect ();
  1036. spin_lock_bh (&this->chip_lock);
  1037. this->state = FL_READY;
  1038. wake_up (&this->wq);
  1039. spin_unlock_bh (&this->chip_lock);
  1040. return -EIO;
  1041. }
  1042. }
  1044. #ifdef CONFIG_MTD_NAND_ECC
  1045. /*
  1046.  * We also want to check that the ECC bytes wrote
  1047.  * correctly for the same reasons stated above.
  1048.  */
  1049. nand_command (mtd, NAND_CMD_READOOB, 0x00, page);
  1050. for (i=0 ; i < ecc_bytes ; i++) {
  1051. if ((readb (this->IO_ADDR) != this->ecc_code_buf[i]) &&
  1052. this->ecc_code_buf[i]) {
  1053. DEBUG (MTD_DEBUG_LEVEL0,
  1054. "nand_writev: Failed ECC write " 
  1055. "verify, page 0x%08x, " 
  1056. "%6i bytes were succesfuln",
  1057. page, i);
  1058. nand_deselect ();
  1059. spin_lock_bh (&this->chip_lock);
  1060. this->state = FL_READY;
  1061. wake_up (&this->wq);
  1062. spin_unlock_bh (&this->chip_lock);
  1063. return -EIO;
  1064. }
  1065. }
  1066. #endif
  1068. #endif
  1069. /* Update written bytes count */
  1070. *retlen += (cnt - col);
  1072. /* Reset written byte counter and column */
  1073. col = cnt = 0;
  1075. /* Increment page address */
  1076. page++;
  1077. }
  1079. /* De-select the NAND device */
  1080. nand_deselect ();
  1082. /* Wake up anyone waiting on the device */
  1083. spin_lock_bh (&this->chip_lock);
  1084. this->state = FL_READY;
  1085. wake_up (&this->wq);
  1086. spin_unlock_bh (&this->chip_lock);
  1088. /* Return happy */
  1089. return 0;
  1090. }
  1092. /*
  1093.  * NAND erase a block
  1094.  */
  1095. static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
  1096. {
  1097. int i, page, len, status, pages_per_block;
  1098. struct nand_chip *this = mtd->priv;
  1099. DECLARE_WAITQUEUE(wait, current);
  1101. DEBUG (MTD_DEBUG_LEVEL3,
  1102. "nand_erase: start = 0x%08x, len = %in",
  1103. (unsigned int) instr->addr, (unsigned int) instr->len);
  1105. /* Start address must align on block boundary */
  1106. if (instr->addr & (mtd->erasesize - 1)) {
  1107. DEBUG (MTD_DEBUG_LEVEL0,
  1108. "nand_erase: Unaligned addressn");
  1109. return -EINVAL;
  1110. }
  1112. /* Length must align on block boundary */
  1113. if (instr->len & (mtd->erasesize - 1)) {
  1114. DEBUG (MTD_DEBUG_LEVEL0,
  1115. "nand_erase: Length not block alignedn");
  1116. return -EINVAL;
  1117. }
  1119. /* Do not allow erase past end of device */
  1120. if ((instr->len + instr->addr) > mtd->size) {
  1121. DEBUG (MTD_DEBUG_LEVEL0,
  1122. "nand_erase: Erase past end of devicen");
  1123. return -EINVAL;
  1124. }
  1126. retry:
  1127. /* Grab the lock and see if the device is available */
  1128. spin_lock_bh (&this->chip_lock);
  1130. switch (this->state) {
  1131. case FL_READY:
  1132. this->state = FL_ERASING;
  1133. break;
  1135. default:
  1136. set_current_state (TASK_UNINTERRUPTIBLE);
  1137. add_wait_queue (&this->wq, &wait);
  1138. spin_unlock_bh (&this->chip_lock);
  1139. schedule();
  1141. remove_wait_queue (&this->wq, &wait);
  1142. goto retry;
  1143. };
  1145. /* Shift to get first page */
  1146. page = (int) (instr->addr >> this->page_shift);
  1148. /* Calculate pages in each block */
  1149. pages_per_block = mtd->erasesize / mtd->oobblock;
  1151. /* Select the NAND device */
  1152. nand_select ();
  1154. /* Check the WP bit */
  1155. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1156. if (!(readb (this->IO_ADDR) & 0x80)) {
  1157. DEBUG (MTD_DEBUG_LEVEL0,
  1158. "nand_erase: Device is write protected!!!n");
  1159. nand_deselect ();
  1160. this->state = FL_READY;
  1161. spin_unlock_bh (&this->chip_lock);
  1162. return -EIO;
  1163. }
  1165. /* Loop through the pages */
  1166. len = instr->len;
  1167. while (len) {
  1168. /* Send commands to erase a page */
  1169. nand_command(mtd, NAND_CMD_ERASE1, -1, page);
  1170. nand_command(mtd, NAND_CMD_ERASE2, -1, -1);
  1172. /*
  1173.  * Wait for program operation to complete. This could
  1174.  * take up to 4000us (4ms) on some devices, so we try
  1175.  * and exit as quickly as possible.
  1176.  */
  1177. status = 0;
  1178. for (i=0 ; i<32 ; i++) {
  1179. /* Delay for 125us */
  1180. udelay (125);
  1182. /* Check the status */
  1183. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1184. status = (int) readb (this->IO_ADDR);
  1185. if (status & 0x40)
  1186. break;
  1187. }
  1189. /* See if block erase succeeded */
  1190. if (status & 0x01) {
  1191. DEBUG (MTD_DEBUG_LEVEL0,
  1192. "nand_erase: " 
  1193. "Failed erase, page 0x%08xn", page);
  1194. nand_deselect ();
  1195. this->state = FL_READY;
  1196. spin_unlock_bh (&this->chip_lock);
  1197. return -EIO;
  1198. }
  1200. /* Increment page address and decrement length */
  1201. len -= mtd->erasesize;
  1202. page += pages_per_block;
  1204. /* Release the spin lock */
  1205. spin_unlock_bh (&this->chip_lock);
  1207. erase_retry:
  1208. /* Check the state and sleep if it changed */
  1209. spin_lock_bh (&this->chip_lock);
  1210. if (this->state == FL_ERASING) {
  1211. continue;
  1212. }
  1213. else {
  1214. set_current_state (TASK_UNINTERRUPTIBLE);
  1215. add_wait_queue (&this->wq, &wait);
  1216. spin_unlock_bh (&this->chip_lock);
  1217. schedule();
  1219. remove_wait_queue (&this->wq, &wait);
  1220. goto erase_retry;
  1221. }
  1222. }
  1223. spin_unlock_bh (&this->chip_lock);
  1225. /* De-select the NAND device */
  1226. nand_deselect ();
  1228. /* Do call back function */
  1229. if (instr->callback)
  1230. instr->callback (instr);
  1232. /* The device is ready */
  1233. spin_lock_bh (&this->chip_lock);
  1234. this->state = FL_READY;
  1235. spin_unlock_bh (&this->chip_lock);
  1237. /* Return happy */
  1238. return 0;
  1239. }
  1241. /*
  1242.  * NAND sync
  1243.  */
  1244. static void nand_sync (struct mtd_info *mtd)
  1245. {
  1246. struct nand_chip *this = mtd->priv;
  1247. DECLARE_WAITQUEUE(wait, current);
  1249. DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: calledn");
  1251. retry:
  1252. /* Grab the spinlock */
  1253. spin_lock_bh(&this->chip_lock);
  1255. /* See what's going on */
  1256. switch(this->state) {
  1257. case FL_READY:
  1258. case FL_SYNCING:
  1259. this->state = FL_SYNCING;
  1260. spin_unlock_bh (&this->chip_lock);
  1261. break;
  1263. default:
  1264. /* Not an idle state */
  1265. add_wait_queue (&this->wq, &wait);
  1266. spin_unlock_bh (&this->chip_lock);
  1267. schedule ();
  1269. remove_wait_queue (&this->wq, &wait);
  1270. goto retry;
  1271. }
  1273.         /* Lock the device */
  1274. spin_lock_bh (&this->chip_lock);
  1276. /* Set the device to be ready again */
  1277. if (this->state == FL_SYNCING) {
  1278. this->state = FL_READY;
  1279. wake_up (&this->wq);
  1280. }
  1282.         /* Unlock the device */
  1283. spin_unlock_bh (&this->chip_lock);
  1284. }
  1286. /*
  1287.  * Scan for the NAND device
  1288.  */
  1289. int nand_scan (struct mtd_info *mtd)
  1290. {
  1291. int i, nand_maf_id, nand_dev_id;
  1292. struct nand_chip *this = mtd->priv;
  1294. /* Select the device */
  1295. nand_select ();
  1297. /* Send the command for reading device ID */
  1298. nand_command (mtd, NAND_CMD_READID, 0x00, -1);
  1300. /* Read manufacturer and device IDs */
  1301. nand_maf_id = readb (this->IO_ADDR);
  1302. nand_dev_id = readb (this->IO_ADDR);
  1304. /* Print and store flash device information */
  1305. for (i = 0; nand_flash_ids[i].name != NULL; i++) {
  1306. if (nand_maf_id == nand_flash_ids[i].manufacture_id &&
  1307.     nand_dev_id == nand_flash_ids[i].model_id) {
  1308. if (!mtd->size) {
  1309. mtd->name = nand_flash_ids[i].name;
  1310. mtd->erasesize = nand_flash_ids[i].erasesize;
  1311. mtd->size = (1 << nand_flash_ids[i].chipshift);
  1312. mtd->eccsize = 256;
  1313. if (nand_flash_ids[i].page256) {
  1314. mtd->oobblock = 256;
  1315. mtd->oobsize = 8;
  1316. this->page_shift = 8;
  1317. }
  1318. else {
  1319. mtd->oobblock = 512;
  1320. mtd->oobsize = 16;
  1321. this->page_shift = 9;
  1322. }
  1323. }
  1324. printk (KERN_INFO "NAND device: Manufacture ID:" 
  1325. " 0x%02x, Chip ID: 0x%02x (%s)n",
  1326.        nand_maf_id, nand_dev_id, mtd->name);
  1327. break;
  1328. }
  1329. }
  1331. /* Initialize state and spinlock */
  1332. this->state = FL_READY;
  1333. spin_lock_init(&this->chip_lock);
  1335. /* De-select the device */
  1336. nand_deselect ();
  1338. /* Print warning message for no device */
  1339. if (!mtd->size) {
  1340. printk (KERN_WARNING "No NAND device found!!!n");
  1341. return 1;
  1342. }
  1344. /* Fill in remaining MTD driver data */
  1345. mtd->type = MTD_NANDFLASH;
  1346. mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
  1347. mtd->module = THIS_MODULE;
  1348. mtd->ecctype = MTD_ECC_SW;
  1349. mtd->erase = nand_erase;
  1350. mtd->point = NULL;
  1351. mtd->unpoint = NULL;
  1352. mtd->read = nand_read;
  1353. mtd->write = nand_write;
  1354. mtd->read_ecc = nand_read_ecc;
  1355. mtd->write_ecc = nand_write_ecc;
  1356. mtd->read_oob = nand_read_oob;
  1357. mtd->write_oob = nand_write_oob;
  1358. mtd->readv = NULL;
  1359. mtd->writev = nand_writev;
  1360. mtd->sync = nand_sync;
  1361. mtd->lock = NULL;
  1362. mtd->unlock = NULL;
  1363. mtd->suspend = NULL;
  1364. mtd->resume = NULL;
  1366. /* Return happy */
  1367. return 0;
  1368. }
  1370. EXPORT_SYMBOL(nand_scan);
  1372. MODULE_LICENSE("GPL");
  1373. MODULE_AUTHOR("Steven J. Hill <sjhill@cotw.com");
  1374. MODULE_DESCRIPTION("Generic NAND flash driver code");