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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nand.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：33k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nand.c：源码内容
  1. /*
  2.  *  drivers/mtd/nand.c
  3.  *
  4.  *  Copyright (C) 2000 Steven J. Hill (sjhill@cotw.com)
  5.  *
  6.  *  10-29-2001  Thomas Gleixner (gleixner@autronix.de)
  7.  *  - Changed nand_chip structure for controlline function to
  8.  * support different hardware structures (Access to
  9.  * controllines ALE,CLE,NCE via hardware specific function. 
  10.  * - exit out of "failed erase block" changed, to avoid
  11.  * driver hangup
  12.  * - init_waitqueue_head added in function nand_scan !!
  13.  *
  14.  *  01-30-2002  Thomas Gleixner (gleixner@autronix.de)
  15.  * change in nand_writev to block invalid vecs entries
  16.  *
  17.  *  02-11-2002  Thomas Gleixner (gleixner@autronix.de)
  18.  * - major rewrite to avoid duplicated code
  19.  *   common nand_write_page function  
  20.  *   common get_chip function 
  21.  * - added oob_config structure for out of band layouts
  22.  * - write_oob changed for partial programming
  23.  * - read cache for faster access for subsequent reads
  24.  * from the same page.
  25.  * - support for different read/write address
  26.  * - support for device ready/busy line
  27.  * - read oob for more than one page enabled
  28.  *
  29.  *  02-27-2002 Thomas Gleixner (gleixner@autronix.de)
  30.  * - command-delay can be programmed
  31.  * - fixed exit from erase with callback-function enabled
  32.  *
  33.  * $Id: nand.c,v 1.18 2002/02/27 00:12:10 gleixner Exp $
  34.  *
  35.  * This program is free software; you can redistribute it and/or modify
  36.  * it under the terms of the GNU General Public License version 2 as
  37.  * published by the Free Software Foundation.
  38.  *
  39.  *  Overview:
  40.  *   This is the generic MTD driver for NAND flash devices. It should be
  41.  *   capable of working with almost all NAND chips currently available.
  42.  */
  44. #include <linux/delay.h>
  45. #include <linux/errno.h>
  46. #include <linux/sched.h>
  47. #include <linux/types.h>
  48. #include <linux/mtd/mtd.h>
  49. #include <linux/mtd/nand.h>
  50. #include <linux/mtd/nand_ids.h>
  51. #include <linux/interrupt.h>
  52. #include <asm/io.h>
  54. #ifdef CONFIG_MTD_NAND_ECC
  55. #include <linux/mtd/nand_ecc.h>
  56. #endif
  58. /*
  59.  * Macros for low-level register control
  60.  */
  61. #define nand_select() this->hwcontrol(NAND_CTL_SETNCE); 
  62. nand_command(mtd, NAND_CMD_RESET, -1, -1); 
  63. udelay (this->chip_delay);
  65. #define nand_deselect() this->hwcontrol(NAND_CTL_CLRNCE);
  67. /*
  68.  * Definition of the out of band configuration structure
  69.  */
  70. struct nand_oob_config {
  71. int ecc_pos[6]; /* position of ECC bytes inside oob */
  72. int badblock_pos; /* position of bad block flag inside oob -1 = inactive */
  73. int eccvalid_pos; /* position of ECC valid flag inside oob -1 = inactive */
  74. };
  76. /*
  77. * Constants for oob configuration
  78. */
  79. #define NAND_NOOB_ECCPOS0 0
  80. #define NAND_NOOB_ECCPOS1 1
  81. #define NAND_NOOB_ECCPOS2 2
  82. #define NAND_NOOB_ECCPOS3 3
  83. #define NAND_NOOB_ECCPOS4 4
  84. #define NAND_NOOB_ECCPOS5 5
  85. #define NAND_NOOB_BADBPOS -1
  86. #define NAND_NOOB_ECCVPOS -1
  88. #define NAND_JFFS2_OOB_ECCPOS0 0
  89. #define NAND_JFFS2_OOB_ECCPOS1 1
  90. #define NAND_JFFS2_OOB_ECCPOS2 2
  91. #define NAND_JFFS2_OOB_ECCPOS3 3
  92. #define NAND_JFFS2_OOB_ECCPOS4 6
  93. #define NAND_JFFS2_OOB_ECCPOS5 7
  94. #define NAND_JFFS2_OOB_BADBPOS 5
  95. #define NAND_JFFS2_OOB_ECCVPOS 4
  97. static struct nand_oob_config oob_config;
  98. /*
  99.  * NAND low-level MTD interface functions
  100.  */
  101. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
  102. size_t *retlen, u_char *buf);
  103. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  104. size_t *retlen, u_char *buf, u_char *ecc_code);
  105. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
  106. size_t *retlen, u_char *buf);
  107. static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
  108. size_t *retlen, const u_char *buf);
  109. static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
  110. size_t *retlen, const u_char *buf,
  111. u_char *ecc_code);
  112. static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
  113. size_t *retlen, const u_char *buf);
  114. static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
  115. unsigned long count, loff_t to, size_t *retlen);
  116. static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
  117. static void nand_sync (struct mtd_info *mtd);
  118. static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this,
  119. int page, int col, int last, u_char *ecc_code);
  121. /*
  122.  * Send command to NAND device
  123.  */
  124. static void nand_command (struct mtd_info *mtd, unsigned command,
  125. int column, int page_addr)
  126. {
  127. register struct nand_chip *this = mtd->priv;
  128. register unsigned long NAND_IO_ADDR = this->IO_ADDR_W;
  130. /* Begin command latch cycle */
  131. this->hwcontrol(NAND_CTL_SETCLE);
  133. /*
  134.  * Write out the command to the device.
  135.  */
  136. if (command != NAND_CMD_SEQIN)
  137. writeb (command, NAND_IO_ADDR);
  138. else {
  139. if (mtd->oobblock == 256 && column >= 256) {
  140. column -= 256;
  141. writeb(NAND_CMD_RESET, NAND_IO_ADDR);
  142. writeb(NAND_CMD_READOOB, NAND_IO_ADDR);
  143. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  144. }
  145. else if (mtd->oobblock == 512 && column >= 256) {
  146. if (column < 512) {
  147. column -= 256;
  148. writeb(NAND_CMD_READ1, NAND_IO_ADDR);
  149. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  150. }
  151. else {
  152. column -= 512;
  153. writeb(NAND_CMD_READOOB, NAND_IO_ADDR);
  154. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  155. }
  156. }
  157. else {
  158. writeb(NAND_CMD_READ0, NAND_IO_ADDR);
  159. writeb(NAND_CMD_SEQIN, NAND_IO_ADDR);
  160. }
  161. }
  163. /* Set ALE and clear CLE to start address cycle */
  164. this->hwcontrol(NAND_CTL_CLRCLE);
  166. if (column != -1 || page_addr != -1)
  167. this->hwcontrol(NAND_CTL_SETALE);
  169. /* Serially input address */
  170. if (column != -1)
  171. writeb (column, NAND_IO_ADDR);
  172. if (page_addr != -1) {
  173. writeb ((unsigned char) (page_addr & 0xff), NAND_IO_ADDR);
  174. writeb ((unsigned char) ((page_addr >> 8) & 0xff), NAND_IO_ADDR);
  175. /* One more address cycle for higher density devices */
  176. if (mtd->size & 0x0c000000) {
  177. writeb ((unsigned char) ((page_addr >> 16) & 0x0f),
  178. NAND_IO_ADDR);
  179. }
  180. }
  181. /* Latch in address */
  182. if (column != -1 || page_addr != -1)
  183. this->hwcontrol(NAND_CTL_CLRALE);
  185. /* Pause for 15us */
  186. udelay (this->chip_delay);
  187. }
  189. /*
  190.  * Get chip for selected access
  191.  */
  192. static inline void nand_get_chip(struct nand_chip *this,int new_state, int *erase_state) {
  194. DECLARE_WAITQUEUE(wait, current);
  196. /* Grab the lock and see if the device is available */
  197. retry:
  198. spin_lock_bh (&this->chip_lock);
  200. switch (this->state) {
  201. case FL_READY:
  202. this->state = new_state;
  203. if (new_state != FL_ERASING)
  204. spin_unlock_bh (&this->chip_lock);
  205. break;
  207. case FL_ERASING:
  208. if (new_state == FL_READING) {
  209. this->state = FL_READING;
  210. *erase_state = 1;
  211. spin_unlock_bh (&this->chip_lock);
  212. break;
  213. }
  215. default:
  216. set_current_state (TASK_UNINTERRUPTIBLE);
  217. add_wait_queue (&this->wq, &wait);
  218. spin_unlock_bh (&this->chip_lock);
  219. schedule();
  221. remove_wait_queue (&this->wq, &wait);
  222. goto retry;
  223. };
  224. }
  226. /*
  227.  * Nand_page_program function is used for write and writev !
  228.  */
  229. static int nand_write_page(struct mtd_info *mtd, struct nand_chip *this,
  230. int page,int col, int last, u_char *ecc_code) {
  232. int i, status;
  233. #ifdef CONFIG_MTD_NAND_ECC
  234. int ecc_bytes = (mtd->oobblock == 512) ? 6 : 3;
  235. #endif
  236. /* pad oob area */
  237. for(i=mtd->oobblock;i < mtd->oobblock+mtd->oobsize; i++)
  238. this->data_buf[i] = 0xff;
  240. #ifdef CONFIG_MTD_NAND_ECC
  241. /* Zero out the ECC array */
  242. for (i=0 ; i < 6 ; i++)
  243. ecc_code[i] = 0x00;
  245. /* Read back previous written data, if col > 0 */
  246. if(col) {
  247. nand_command (mtd, NAND_CMD_READ0, col, page);
  248. for (i=0 ; i < col ; i++)
  249. this->data_buf[i] = readb (this->IO_ADDR_R); 
  250. }
  252. /* Calculate and write the ECC if we have enough data */
  253. if ((col < mtd->eccsize) && (last >= mtd->eccsize)) {
  254. nand_calculate_ecc (&this->data_buf[0], &(ecc_code[0]));
  255. for (i=0 ; i<3 ; i++)
  256. this->data_buf[(mtd->oobblock + oob_config.ecc_pos[i])] =
  257. ecc_code[i];
  258. if (oob_config.eccvalid_pos != -1)
  259. this->data_buf[mtd->oobblock + oob_config.eccvalid_pos] = 0xf0;
  260. }
  262. /* Calculate and write the second ECC if we have enough data */
  263. if ((mtd->oobblock == 512) && (last == mtd->oobblock)) {
  264. nand_calculate_ecc (&this->data_buf[256],&(ecc_code[3]));
  265. for (i=3 ; i<6 ; i++)
  266. this->data_buf[(mtd->oobblock + oob_config.ecc_pos[i])] =
  267. ecc_code[i];
  268. if (oob_config.eccvalid_pos != -1)
  269. this->data_buf[mtd->oobblock + oob_config.eccvalid_pos] &= 0x0f;
  270. }
  271. #endif
  272. /* Prepad for partial page programming !!! */
  273. for (i=0 ; i < col ; i++)
  274. this->data_buf[i] = 0xff; 
  276. /* Postpad for partial page programming !!! oob is already padded */
  277. for (i=last ; i < mtd->oobblock ; i++)
  278. this->data_buf[i] = 0xff; 
  280. /* Send command to begin auto page programming */
  281. nand_command (mtd, NAND_CMD_SEQIN, 0x00, page);
  283. /* Write out complete page of data */
  284. for (i=0 ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  285. writeb (this->data_buf[i], this->IO_ADDR_W);
  287. /* Send command to actually program the data */
  288. nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  290. /*
  291.  * Wait for program operation to complete. This could
  292.  * take up to 3000us (3ms) on some devices, so we try
  293.  * and exit as quickly as possible.
  294.  */
  295. status = 0;
  296. for (i=0 ; i<24 ; i++) {
  297. /* Delay for 125us */
  298. udelay (125);
  299. /* Check the status */
  300. if (this->dev_ready) 
  301. if (!this->dev_ready())
  302. continue;
  304. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  305. status = (int) readb (this->IO_ADDR_R);
  306. if (status & 0x40)
  307. break;
  308. }
  309. /* See if device thinks it succeeded */
  310. if (status & 0x01) {
  311. DEBUG (MTD_DEBUG_LEVEL0,
  312. "nand_write_ecc: " 
  313. "Failed write, page 0x%08x, " 
  314. "%6i bytes were succesfuln", page, *retlen);
  315. return -EIO;
  316. }
  318. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  319. /*
  320.  * The NAND device assumes that it is always writing to
  321.  * a cleanly erased page. Hence, it performs its internal
  322.  * write verification only on bits that transitioned from
  323.  * 1 to 0. The device does NOT verify the whole page on a
  324.  * byte by byte basis. It is possible that the page was
  325.  * not completely erased or the page is becoming unusable
  326.  * due to wear. The read with ECC would catch the error
  327.  * later when the ECC page check fails, but we would rather
  328.  * catch it early in the page write stage. Better to write
  329.  * no data than invalid data.
  330.  */
  332. /* Send command to read back the page */
  333. if (col < mtd->eccsize)
  334. nand_command (mtd, NAND_CMD_READ0, col, page);
  335. else
  336. nand_command (mtd, NAND_CMD_READ1, col - 256, page);
  338. /* Loop through and verify the data */
  339. for (i=col ; i < last ; i++) {
  340. if (this->data_buf[i] != readb (this->IO_ADDR_R)) {
  341. DEBUG (MTD_DEBUG_LEVEL0,
  342. "nand_write_ecc: " 
  343. "Failed write verify, page 0x%08x, " 
  344. "%6i bytes were succesfuln",
  345. page, *retlen);
  346. return -EIO;
  347. }
  348. }
  350. #ifdef CONFIG_MTD_NAND_ECC
  351. /*
  352.  * We also want to check that the ECC bytes wrote
  353.  * correctly for the same reasons stated above.
  354.  */
  355. nand_command (mtd, NAND_CMD_READOOB, 0x00, page);
  356. for (i=0 ; i < mtd->oobsize ; i++)
  357. this->data_buf[i] = readb(this->IO_ADDR_R);
  358. for (i=0 ; i < ecc_bytes ; i++) {
  359. if ( (this->data_buf[(oob_config.ecc_pos[i])] != ecc_code[i]) && ecc_code[i]) {
  360. DEBUG (MTD_DEBUG_LEVEL0,
  361. "nand_write_ecc: Failed ECC write " 
  362. "verify, page 0x%08x, " 
  363. "%6i bytes were succesfuln",
  364. page, i);
  365. return -EIO;
  366. }
  367. }
  368. #endif
  369. #endif
  370. return 0;
  371. }
  373. /*
  374.  * NAND read
  375.  */
  376. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
  377. size_t *retlen, u_char *buf)
  378. {
  379. #ifdef CONFIG_MTD_NAND_ECC
  380. struct nand_chip *this = mtd->priv;
  382. return nand_read_ecc (mtd, from, len, retlen, buf, this->ecc_code_buf);
  383. #else
  384. return nand_read_ecc (mtd, from, len, retlen, buf, NULL);
  385. #endif
  386. }
  388. /*
  389.  * NAND read with ECC
  390.  */
  391. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  392. size_t *retlen, u_char *buf, u_char *ecc_code)
  393. {
  394. int  j, col, page;
  395. int  erase_state = 0;
  396. int ecc_status = 0, ecc_failed = 0;
  397. struct  nand_chip *this = mtd->priv;
  398. u_char *data_poi;
  399. #ifdef CONFIG_MTD_NAND_ECC
  400. u_char ecc_calc[6];
  401. #endif
  403. DEBUG (MTD_DEBUG_LEVEL3,
  404. "nand_read_ecc: from = 0x%08x, len = %in", (unsigned int) from,
  405. (int) len);
  407. /* Do not allow reads past end of device */
  408. if ((from + len) > mtd->size) {
  409. DEBUG (MTD_DEBUG_LEVEL0,
  410. "nand_read_ecc: Attempt read beyond end of devicen");
  411. *retlen = 0;
  412. return -EINVAL;
  413. }
  415. /* Grab the lock and see if the device is available */
  416. nand_get_chip(this,FL_READING,&erase_state);
  418. /* First we calculate the starting page */
  419. page = from >> this->page_shift;
  421. /* Get raw starting column */
  422. col = from & (mtd->oobblock - 1);
  424. /* Initialize return value */
  425. *retlen = 0;
  427. /* Select the NAND device */
  428. nand_select ();
  430. /* Loop until all data read */
  431. while (*retlen < len) {
  433. #ifdef CONFIG_MTD_NAND_ECC
  435. /* Do we have this page in cache ? */
  436. if (this->cache_page == page)
  437. goto readdata;
  439. /* Send the read command */
  440. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  441. /* Read in a page + oob data*/
  442. for (j=0 ; j < mtd->oobblock + mtd->oobsize ; j++) 
  443. this->data_buf[j] = readb (this->IO_ADDR_R);
  444. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  446. /* copy data into cache, for read out of cache and if ecc fails */
  447. if (this->data_cache)
  448. memcpy(this->data_cache,this->data_buf,mtd->oobblock+mtd->oobsize);
  450. /* Pick the ECC bytes out of the oob data*/
  451. for (j=0 ; j < 6 ; j++)
  452. ecc_code[j] = this->data_buf[(mtd->oobblock + oob_config.ecc_pos[j])];
  454. /* Calculate the ECC and verify it */
  455. /* If block was not written with ECC, skip ECC */
  456. if (oob_config.eccvalid_pos != -1 && 
  457. (this->data_buf[mtd->oobblock+oob_config.eccvalid_pos] & 0x0f) != 0x0f ) {
  459. nand_calculate_ecc (&this->data_buf[0], &ecc_calc[0]);
  460. switch (nand_correct_data (&this->data_buf[0],&ecc_code[0], &ecc_calc[0])) {
  461. case -1:
  462. DEBUG (MTD_DEBUG_LEVEL0,"nand_read_ecc: " 
  463. "Failed ECC read, page 0x%08xn", page);
  464. ecc_failed++;
  465. break;
  466. case  1:
  467. case  2:/* transfer ECC corrected data to cache */
  468. memcpy(this->data_cache,this->data_buf,256);
  469. break;
  470. }
  471. }
  473. if (oob_config.eccvalid_pos != -1 && 
  474. mtd->oobblock == 512 &&
  475. (this->data_buf[mtd->oobblock+oob_config.eccvalid_pos] & 0xf0) != 0xf0 ) {
  477. nand_calculate_ecc (&this->data_buf[256],&ecc_calc[3]);
  478. switch (nand_correct_data (&this->data_buf[256],&ecc_code[3], &ecc_calc[3])) {
  479. case -1:
  480. DEBUG (MTD_DEBUG_LEVEL0,"nand_read_ecc: " 
  481. "Failed ECC read, page 0x%08xn", page);
  482. ecc_failed++;
  483. break;
  484. case  1:
  485. case  2:/* transfer ECC corrected data to cache */
  486. if (this->data_cache)
  487. memcpy(&this->data_cache[256],&this->data_buf[256],256);
  488. break;
  489. }
  490. }
  491. readdata:
  492. /* Read the data from ECC data buffer into return buffer */
  493. data_poi = (this->data_cache) ? this->data_cache : this->data_buf;
  494. data_poi += col; 
  495. if ((*retlen + (mtd->oobblock - col)) >= len) {
  496. while (*retlen < len)
  497. buf[(*retlen)++] = *data_poi++;
  498. }
  499. else {
  500. for (j=col ; j < mtd->oobblock ; j++)
  501. buf[(*retlen)++] = *data_poi++;
  502. }
  503. /* Set cache page address, invalidate, if ecc_failed */
  504. this->cache_page = (this->data_cache && !ecc_failed) ? page : -1;
  506. ecc_status += ecc_failed;
  507. ecc_failed = 0;
  509. #else
  510. /* Send the read command */
  511. nand_command (mtd, NAND_CMD_READ0, col, page);
  513. /* Read the data directly into the return buffer */ 
  514. if ((*retlen + (mtd->oobblock - col)) >= len) {
  515. while (*retlen < len)
  516. buf[(*retlen)++] = readb (this->IO_ADDR_R);
  517. /* We're done */
  518. continue;
  519. }
  520. else
  521. for (j=col ; j < mtd->oobblock; j++)
  522. buf[(*retlen)++] = readb (this->IO_ADDR_R);
  523. #endif
  524. /* For subsequent reads align to page boundary. */
  525. col = 0;
  526. /* Increment page address */
  527. page++;
  528. }
  530. /* De-select the NAND device */
  531. nand_deselect ();
  533. /* Wake up anyone waiting on the device */
  534. spin_lock_bh (&this->chip_lock);
  535. if (erase_state)
  536. this->state = FL_ERASING;
  537. else
  538. this->state = FL_READY;
  539. wake_up (&this->wq);
  540. spin_unlock_bh (&this->chip_lock);
  542. /*
  543.  * Return success, if no ECC failures, else -EIO
  544.  * fs driver will take care of that, because
  545.  * retlen == desired len and result == -EIO
  546.  */
  547. return ecc_status ? -EIO : 0;
  548. }
  550. /*
  551.  * NAND read out-of-band
  552.  */
  553. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
  554. size_t *retlen, u_char *buf)
  555. {
  556. int i, col, page;
  557. int erase_state = 0;
  558. struct nand_chip *this = mtd->priv;
  560. DEBUG (MTD_DEBUG_LEVEL3,
  561. "nand_read_oob: from = 0x%08x, len = %in", (unsigned int) from,
  562. (int) len);
  564. /* Shift to get page */
  565. page = ((int) from) >> this->page_shift;
  567. /* Mask to get column */
  568. col = from & 0x0f;
  570. /* Initialize return length value */
  571. *retlen = 0;
  573. /* Do not allow reads past end of device */
  574. if ((from + len) > mtd->size) {
  575. DEBUG (MTD_DEBUG_LEVEL0,
  576. "nand_read_oob: Attempt read beyond end of devicen");
  577. *retlen = 0;
  578. return -EINVAL;
  579. }
  581. /* Grab the lock and see if the device is available */
  582. nand_get_chip(this,FL_READING,&erase_state);
  584. /* can we read out of cache ? */
  585. if (this->cache_page == page && (col+len <= mtd->oobsize)) {
  586. /* Read the data */
  587. memcpy(buf,&this->data_cache[mtd->oobblock+col],len);
  588. } else {
  590. /* Select the NAND device */
  591. nand_select ();
  593. /* Send the read command */
  594. nand_command (mtd, NAND_CMD_READOOB, col, page);
  595. /* 
  596.  * Read the data, if we read more than one page
  597.  * oob data, let the device transfer the data !
  598.  */
  599. for (i = 0 ; i < len ; i++) {
  600. buf[i] = readb (this->IO_ADDR_R);
  601. if ( (col++ & (mtd->oobsize-1)) == (mtd->oobsize-1) )
  602. udelay(this->chip_delay);
  603. }
  604. /* De-select the NAND device */
  605. nand_deselect ();
  606. }
  608. /* Wake up anyone waiting on the device */
  609. spin_lock_bh (&this->chip_lock);
  610. if (erase_state)
  611. this->state = FL_ERASING;
  612. else
  613. this->state = FL_READY;
  614. wake_up (&this->wq);
  615. spin_unlock_bh (&this->chip_lock);
  617. /* Return happy */
  618. *retlen = len;
  619. return 0;
  620. }
  622. /*
  623.  * NAND write
  624.  */
  625. static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
  626. size_t *retlen, const u_char *buf)
  627. {
  628. #ifdef CONFIG_MTD_NAND_ECC
  629. struct nand_chip *this = mtd->priv;
  631. return nand_write_ecc (mtd, to, len, retlen, buf, this->ecc_code_buf);
  632. #else
  633. return nand_write_ecc (mtd, to, len, retlen, buf, NULL);
  634. #endif
  635. }
  637. /*
  638.  * NAND write with ECC
  639.  */
  640. static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
  641. size_t *retlen, const u_char *buf,
  642. u_char *ecc_code)
  643. {
  644. int i, page, col, cnt, ret = 0;
  645. struct nand_chip *this = mtd->priv;
  647. DEBUG (MTD_DEBUG_LEVEL3,
  648. "nand_write_ecc: to = 0x%08x, len = %in", (unsigned int) to,
  649. (int) len);
  651. /* Do not allow write past end of device */
  652. if ((to + len) > mtd->size) {
  653. DEBUG (MTD_DEBUG_LEVEL0,
  654. "nand_write_oob: Attempt to write past end of pagen");
  655. return -EINVAL;
  656. }
  658. /* Grab the lock and see if the device is available */
  659. nand_get_chip(this,FL_WRITING,NULL);
  661. /* Shift to get page */
  662. page = ((int) to) >> this->page_shift;
  664. /* Get the starting column */
  665. col = to & (mtd->oobblock - 1);
  667. /* Initialize return length value */
  668. *retlen = 0;
  670. /* Select the NAND device */
  671. nand_select ();
  673. /* Check the WP bit */
  674. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  675. if (!(readb (this->IO_ADDR_R) & 0x80)) {
  676. DEBUG (MTD_DEBUG_LEVEL0,
  677. "nand_write_ecc: Device is write protected!!!n");
  678. ret = -EIO;
  679. goto out;
  680. }
  682. /* Loop until all data is written */
  683. while (*retlen < len) {
  684. /* Invalidate cache, if we write to this page */
  685. if (this->cache_page == page)
  686. this->cache_page = -1;
  688. /* Write data into buffer */
  689. if ((col + len) >= mtd->oobblock)
  690. for(i=col, cnt=0 ; i < mtd->oobblock ; i++, cnt++)
  691. this->data_buf[i] = buf[(*retlen + cnt)];
  692. else
  693. for(i=col, cnt=0 ; cnt < (len - *retlen) ; i++, cnt++)
  694. this->data_buf[i] = buf[(*retlen + cnt)];
  696. /* We use the same function for write and writev !) */
  697. ret = nand_write_page(mtd,this,page,col,i,ecc_code);
  698. if (ret) 
  699. goto out;
  701. /* Next data start at page boundary */
  702. col = 0;
  704. /* Update written bytes count */
  705. *retlen += cnt;
  707. /* Increment page address */
  708. page++;
  709. }
  711. /* Return happy */
  712. *retlen = len;
  714. out:
  715. /* De-select the NAND device */
  716. nand_deselect ();
  718. /* Wake up anyone waiting on the device */
  719. spin_lock_bh (&this->chip_lock);
  720. this->state = FL_READY;
  721. wake_up (&this->wq);
  722. spin_unlock_bh (&this->chip_lock);
  724. return ret;
  725. }
  727. /*
  728.  * NAND write out-of-band
  729.  */
  730. static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
  731. size_t *retlen, const u_char *buf)
  732. {
  733. int i, column, page, status, ret = 0;
  734. struct nand_chip *this = mtd->priv;
  736. DEBUG (MTD_DEBUG_LEVEL3,
  737. "nand_write_oob: to = 0x%08x, len = %in", (unsigned int) to,
  738. (int) len);
  740. /* Shift to get page */
  741. page = ((int) to) >> this->page_shift;
  743. /* Mask to get column */
  744. column = to & 0x1f;
  746. /* Initialize return length value */
  747. *retlen = 0;
  749. /* Do not allow write past end of page */
  750. if ((column + len) > mtd->oobsize) {
  751. DEBUG (MTD_DEBUG_LEVEL0,
  752. "nand_write_oob: Attempt to write past end of pagen");
  753. return -EINVAL;
  754. }
  756. /* Grab the lock and see if the device is available */
  757. nand_get_chip(this,FL_WRITING,NULL);
  759. /* Select the NAND device */
  760. nand_select ();
  762. /* Check the WP bit */
  763. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  764. if (!(readb (this->IO_ADDR_R) & 0x80)) {
  765. DEBUG (MTD_DEBUG_LEVEL0,
  766. "nand_write_oob: Device is write protected!!!n");
  767. ret = -EIO;
  768. goto out;
  769. }
  771. /* Invalidate cache, if we write to this page */
  772. if (this->cache_page == page)
  773. this->cache_page = -1;
  775. /* Write ones for partial page programming */
  776. for (i=mtd->oobblock ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  777. this->data_buf[i] = 0xff;
  779. /* Transfer data */
  780. for (i = 0; i< len; i++) 
  781. this->data_buf[i+mtd->oobblock+column] = buf[i];
  783. /* Write out desired data */
  784. nand_command (mtd, NAND_CMD_SEQIN, mtd->oobblock, page);
  785. for (i=0 ; i<mtd->oobsize ; i++)
  786. writeb (this->data_buf[i+mtd->oobblock], this->IO_ADDR_W);
  788. /* Send command to program the OOB data */
  789. nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  791. /*
  792.  * Wait for program operation to complete. This could
  793.  * take up to 3000us (3ms) on some devices, so we try
  794.  * and exit as quickly as possible.
  795.  */
  796. status = 0;
  797. for (i=0 ; i<24 ; i++) {
  798. /* Delay for 125us */
  799. udelay (125);
  800. /* Check the status */
  801. if (this->dev_ready) 
  802. if (!this->dev_ready())
  803. continue;
  805. /* Check the status */
  806. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  807. status = (int) readb (this->IO_ADDR_R);
  808. if (status & 0x40)
  809. break;
  810. }
  812. /* See if device thinks it succeeded */
  813. if (status & 0x01) {
  814. DEBUG (MTD_DEBUG_LEVEL0,
  815. "nand_write_oob: " 
  816. "Failed write, page 0x%08xn", page);
  817. ret = -EIO;
  818. goto out;
  819. }
  821. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  822. /* Send command to read back the data */
  823. nand_command (mtd, NAND_CMD_READOOB, column, page);
  825. /* Loop through and verify the data */
  826. for (i=0 ; i<len ; i++) {
  827. if (buf[i] != readb (this->IO_ADDR_R)) {
  828. DEBUG (MTD_DEBUG_LEVEL0,
  829. "nand_write_oob: " 
  830. "Failed write verify, page 0x%08xn", page);
  831. ret = -EIO;
  832. goto out;
  833. }
  834. }
  835. #endif
  836. /* Return happy */
  837. *retlen = len;
  839. out:
  840. /* De-select the NAND device */
  841. nand_deselect ();
  843. /* Wake up anyone waiting on the device */
  844. spin_lock_bh (&this->chip_lock);
  845. this->state = FL_READY;
  846. wake_up (&this->wq);
  847. spin_unlock_bh (&this->chip_lock);
  849. return ret;
  850. }
  852. /*
  853.  * NAND write with iovec
  854.  */
  855. static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
  856. unsigned long count, loff_t to, size_t *retlen)
  857. {
  858. int i, page, col, cnt, len, total_len, ret = 0;
  859. struct nand_chip *this = mtd->priv;
  861. /* Calculate total length of data */
  862. total_len = 0;
  863. for (i=0 ; i < count ; i++)
  864. total_len += (int) vecs[i].iov_len;
  866. DEBUG (MTD_DEBUG_LEVEL3,
  867. "nand_writev: to = 0x%08x, len = %i, count = %ldn", (unsigned int) to,
  868. (unsigned int) total_len, count);
  870. /* Do not allow write past end of page */
  871. if ((to + total_len) > mtd->size) {
  872. DEBUG (MTD_DEBUG_LEVEL0,
  873. "nand_writev: Attempted write past end of devicen");
  874. return -EINVAL;
  875. }
  877. /* Grab the lock and see if the device is available */
  878. nand_get_chip(this,FL_WRITING,NULL);
  880. /* Shift to get page */
  881. page = ((int) to) >> this->page_shift;
  883. /* Get the starting column */
  884. col = to & (mtd->oobblock - 1);
  886. /* Initialize return length value */
  887. *retlen = 0;
  889. /* Select the NAND device */
  890. nand_select ();
  892. /* Check the WP bit */
  893. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  894. if (!(readb (this->IO_ADDR_R) & 0x80)) {
  895. DEBUG (MTD_DEBUG_LEVEL0,
  896. "nand_writev: Device is write protected!!!n");
  897. ret = -EIO;
  898. goto out;
  899. }
  901. /* Loop until all iovecs' data has been written */
  902. cnt = col;
  903. len = 0;
  904. while (count) {
  905. /* Invalidate cache, if we write to this page */
  906. if (this->cache_page == page)
  907. this->cache_page = -1;
  909. /* Do any need pre-fill for partial page programming */
  910. for (i=0 ; i < cnt ; i++)
  911. this->data_buf[i] = 0xff;
  913. /*
  914.  * Read data out of each tuple until we have a full page
  915.  * to write or we've read all the tuples.
  916.  */
  917.  
  918. while ((cnt < mtd->oobblock) && count) {
  919. if (vecs->iov_base!=NULL && vecs->iov_len) {
  920. this->data_buf[cnt++] = 
  921. ((u_char *) vecs->iov_base)[len++];
  922. }
  923. if (len >= (int) vecs->iov_len) {
  924. vecs++;
  925. len = 0;
  926. count--;
  927. }
  928. }
  930. /* We use the same function for write and writev !) */
  931. ret = nand_write_page(mtd,this,page,col,cnt,this->ecc_code_buf);
  932. if (ret)
  933. goto out;
  935. /* Update written bytes count */
  936. *retlen += (cnt - col);
  938. /* Reset written byte counter and column */
  939. col = cnt = 0;
  941. /* Increment page address */
  942. page++;
  943. }
  945. out:
  946. /* De-select the NAND device */
  947. nand_deselect ();
  949. /* Wake up anyone waiting on the device */
  950. spin_lock_bh (&this->chip_lock);
  951. this->state = FL_READY;
  952. wake_up (&this->wq);
  953. spin_unlock_bh (&this->chip_lock);
  955. /* Return happy */
  956. return ret;
  957. }
  959. /*
  960.  * NAND erase a block
  961.  */
  962. static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
  963. {
  964. int i, page, len, status, pages_per_block, ret;
  965. struct nand_chip *this = mtd->priv;
  966. DECLARE_WAITQUEUE(wait, current);
  968. DEBUG (MTD_DEBUG_LEVEL3,
  969. "nand_erase: start = 0x%08x, len = %in",
  970. (unsigned int) instr->addr, (unsigned int) instr->len);
  972. /* Start address must align on block boundary */
  973. if (instr->addr & (mtd->erasesize - 1)) {
  974. DEBUG (MTD_DEBUG_LEVEL0,
  975. "nand_erase: Unaligned addressn");
  976. return -EINVAL;
  977. }
  979. /* Length must align on block boundary */
  980. if (instr->len & (mtd->erasesize - 1)) {
  981. DEBUG (MTD_DEBUG_LEVEL0,
  982. "nand_erase: Length not block alignedn");
  983. return -EINVAL;
  984. }
  986. /* Do not allow erase past end of device */
  987. if ((instr->len + instr->addr) > mtd->size) {
  988. DEBUG (MTD_DEBUG_LEVEL0,
  989. "nand_erase: Erase past end of devicen");
  990. return -EINVAL;
  991. }
  993. /* Grab the lock and see if the device is available */
  994. nand_get_chip(this,FL_ERASING,NULL);
  996. /* Shift to get first page */
  997. page = (int) (instr->addr >> this->page_shift);
  999. /* Calculate pages in each block */
  1000. pages_per_block = mtd->erasesize / mtd->oobblock;
  1002. /* Select the NAND device */
  1003. nand_select ();
  1005. /* Check the WP bit */
  1006. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1007. if (!(readb (this->IO_ADDR_R) & 0x80)) {
  1008. DEBUG (MTD_DEBUG_LEVEL0,
  1009. "nand_erase: Device is write protected!!!n");
  1010. nand_deselect ();
  1011. this->state = FL_READY;
  1012. spin_unlock_bh (&this->chip_lock);
  1013. return -EIO;
  1014. }
  1016. /* Loop through the pages */
  1017. len = instr->len;
  1019. instr->state = MTD_ERASING;
  1021. while (len) {
  1022. if (oob_config.badblock_pos != -1) {
  1023. /* Check if we have a bad block, we do not erase bad blocks !*/
  1024. nand_command (mtd, NAND_CMD_READOOB, oob_config.badblock_pos, page);
  1025. if ( readb(this->IO_ADDR_R) != 0xff) {
  1026. printk(KERN_WARNING "nand_erase: attempt to erase a bad block at page 0x%08xn",page);
  1027. instr->state = MTD_ERASE_FAILED;
  1028. goto erase_exit;
  1029. }
  1030. }
  1032. /* Send commands to erase a page */
  1033. nand_command(mtd, NAND_CMD_ERASE1, -1, page);
  1034. nand_command(mtd, NAND_CMD_ERASE2, -1, -1);
  1036. /*
  1037.  * Wait for program operation to complete. This could
  1038.  * take up to 4000us (4ms) on some devices, so we try
  1039.  * and exit as quickly as possible.
  1040.  */
  1041. status = 0;
  1042. for (i=0 ; i<32 ; i++) {
  1043. /* Delay for 125us */
  1044. udelay (125);
  1045. /* Check the status */
  1046. if (this->dev_ready) 
  1047. if (!this->dev_ready())
  1048. continue;
  1049. /* Check the status */
  1050. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1051. status = (int) readb (this->IO_ADDR_R);
  1052. if (status & 0x40)
  1053. break;
  1054. }
  1056. /* See if block erase succeeded */
  1057. if (status & 0x01) {
  1058. DEBUG (MTD_DEBUG_LEVEL0,
  1059. "nand_erase: " 
  1060. "Failed erase, page 0x%08xn", page);
  1061. instr->state = MTD_ERASE_FAILED;
  1062. goto erase_exit;
  1063. }
  1065. /* Invalidate cache, if last_page is inside erase-block */
  1066. if (this->cache_page >= page && this->cache_page < (page + pages_per_block) ) 
  1067. this->cache_page = -1;
  1069. /* Increment page address and decrement length */
  1070. len -= mtd->erasesize;
  1071. page += pages_per_block;
  1073. /* Release the spin lock */
  1074. spin_unlock_bh (&this->chip_lock);
  1076. erase_retry:
  1077. /* Check the state and sleep if it changed */
  1078. spin_lock_bh (&this->chip_lock);
  1079. if (this->state == FL_ERASING) {
  1080. /* Select the NAND device again, if we were interrupted*/
  1081. nand_select ();
  1082. continue;
  1083. }
  1084. else {
  1085. set_current_state (TASK_UNINTERRUPTIBLE);
  1086. add_wait_queue (&this->wq, &wait);
  1087. spin_unlock_bh (&this->chip_lock);
  1088. schedule();
  1090. remove_wait_queue (&this->wq, &wait);
  1091. goto erase_retry;
  1092. }
  1093. } 
  1094. instr->state = MTD_ERASE_DONE;
  1096. erase_exit:
  1097. spin_unlock_bh (&this->chip_lock);
  1099. /* De-select the NAND device */
  1100. nand_deselect ();
  1102. ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;;
  1103. /* Do call back function */
  1104. if (!ret && instr->callback)
  1105. instr->callback (instr);
  1107. /* The device is ready */
  1108. spin_lock_bh (&this->chip_lock);
  1109. this->state = FL_READY;
  1110. spin_unlock_bh (&this->chip_lock);
  1112. /* Return more or less happy */
  1113. return ret;
  1114. }
  1116. /*
  1117.  * NAND sync
  1118.  */
  1119. static void nand_sync (struct mtd_info *mtd)
  1120. {
  1121. struct nand_chip *this = mtd->priv;
  1122. DECLARE_WAITQUEUE(wait, current);
  1124. DEBUG (MTD_DEBUG_LEVEL3, "nand_sync: calledn");
  1126. retry:
  1127. /* Grab the spinlock */
  1128. spin_lock_bh(&this->chip_lock);
  1130. /* See what's going on */
  1131. switch(this->state) {
  1132. case FL_READY:
  1133. case FL_SYNCING:
  1134. this->state = FL_SYNCING;
  1135. spin_unlock_bh (&this->chip_lock);
  1136. break;
  1138. default:
  1139. /* Not an idle state */
  1140. add_wait_queue (&this->wq, &wait);
  1141. spin_unlock_bh (&this->chip_lock);
  1142. schedule ();
  1144. remove_wait_queue (&this->wq, &wait);
  1145. goto retry;
  1146. }
  1148.         /* Lock the device */
  1149. spin_lock_bh (&this->chip_lock);
  1151. /* Set the device to be ready again */
  1152. if (this->state == FL_SYNCING) {
  1153. this->state = FL_READY;
  1154. wake_up (&this->wq);
  1155. }
  1157.         /* Unlock the device */
  1158. spin_unlock_bh (&this->chip_lock);
  1159. }
  1161. /*
  1162.  * Scan for the NAND device
  1163.  */
  1164. int nand_scan (struct mtd_info *mtd)
  1165. {
  1166. int i, nand_maf_id, nand_dev_id;
  1167. struct nand_chip *this = mtd->priv;
  1169. /* Select the device */
  1170. nand_select ();
  1172. /* Send the command for reading device ID */
  1173. nand_command (mtd, NAND_CMD_READID, 0x00, -1);
  1175. /* Read manufacturer and device IDs */
  1176. nand_maf_id = readb (this->IO_ADDR_R);
  1177. nand_dev_id = readb (this->IO_ADDR_R);
  1179. /* Print and store flash device information */
  1180. for (i = 0; nand_flash_ids[i].name != NULL; i++) {
  1181. if (nand_maf_id == nand_flash_ids[i].manufacture_id &&
  1182.     nand_dev_id == nand_flash_ids[i].model_id) {
  1183. if (!mtd->size) {
  1184. mtd->name = nand_flash_ids[i].name;
  1185. mtd->erasesize = nand_flash_ids[i].erasesize;
  1186. mtd->size = (1 << nand_flash_ids[i].chipshift);
  1187. mtd->eccsize = 256;
  1188. if (nand_flash_ids[i].page256) {
  1189. mtd->oobblock = 256;
  1190. mtd->oobsize = 8;
  1191. this->page_shift = 8;
  1192. }
  1193. else {
  1194. mtd->oobblock = 512;
  1195. mtd->oobsize = 16;
  1196. this->page_shift = 9;
  1197. }
  1198. }
  1199. printk (KERN_INFO "NAND device: Manufacture ID:" 
  1200. " 0x%02x, Chip ID: 0x%02x (%s)n",
  1201.        nand_maf_id, nand_dev_id, mtd->name);
  1202. break;
  1203. }
  1204. }
  1206. /* Initialize state, waitqueue and spinlock */
  1207. this->state = FL_READY;
  1208. init_waitqueue_head(&this->wq);
  1209. spin_lock_init(&this->chip_lock);
  1211. /* De-select the device */
  1212. nand_deselect ();
  1213. /* 
  1214.  * Preset out of band configuration
  1215. */
  1216. #ifdef CONFIG_MTD_NAND_ECC_JFFS2
  1217. oob_config.ecc_pos[0] = NAND_JFFS2_OOB_ECCPOS0;
  1218. oob_config.ecc_pos[1] = NAND_JFFS2_OOB_ECCPOS1;
  1219. oob_config.ecc_pos[2] = NAND_JFFS2_OOB_ECCPOS2;
  1220. oob_config.ecc_pos[3] = NAND_JFFS2_OOB_ECCPOS3;
  1221. oob_config.ecc_pos[4] = NAND_JFFS2_OOB_ECCPOS4;
  1222. oob_config.ecc_pos[5] = NAND_JFFS2_OOB_ECCPOS5;
  1223. oob_config.badblock_pos = 5;
  1224. oob_config.eccvalid_pos = 4;
  1225. #else
  1226. oob_config.ecc_pos[0] = NAND_NOOB_ECCPOS0;
  1227. oob_config.ecc_pos[1] = NAND_NOOB_ECCPOS1;
  1228. oob_config.ecc_pos[2] = NAND_NOOB_ECCPOS2;
  1229. oob_config.ecc_pos[3] = NAND_NOOB_ECCPOS3;
  1230. oob_config.ecc_pos[4] = NAND_NOOB_ECCPOS4;
  1231. oob_config.ecc_pos[5] = NAND_NOOB_ECCPOS5;
  1232. oob_config.badblock_pos = NAND_NOOB_BADBPOS; 
  1233. oob_config.eccvalid_pos = NAND_NOOB_ECCVPOS;
  1234. #endif
  1236. /* Print warning message for no device */
  1237. if (!mtd->size) {
  1238. printk (KERN_WARNING "No NAND device found!!!n");
  1239. return 1;
  1240. }
  1242. /* Fill in remaining MTD driver data */
  1243. mtd->type = MTD_NANDFLASH;
  1244. mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
  1245. mtd->module = THIS_MODULE;
  1246. mtd->ecctype = MTD_ECC_SW;
  1247. mtd->erase = nand_erase;
  1248. mtd->point = NULL;
  1249. mtd->unpoint = NULL;
  1250. mtd->read = nand_read;
  1251. mtd->write = nand_write;
  1252. mtd->read_ecc = nand_read_ecc;
  1253. mtd->write_ecc = nand_write_ecc;
  1254. mtd->read_oob = nand_read_oob;
  1255. mtd->write_oob = nand_write_oob;
  1256. mtd->readv = NULL;
  1257. mtd->writev = nand_writev;
  1258. mtd->sync = nand_sync;
  1259. mtd->lock = NULL;
  1260. mtd->unlock = NULL;
  1261. mtd->suspend = NULL;
  1262. mtd->resume = NULL;
  1264. /* Return happy */
  1265. return 0;
  1266. }
  1268. EXPORT_SYMBOL(nand_scan);
  1270. MODULE_LICENSE("GPL");
  1271. MODULE_AUTHOR("Steven J. Hill <sjhill@cotw.com");
  1272. MODULE_DESCRIPTION("Generic NAND flash driver code");