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

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

嵌入式Linux

开发平台：

Unix_Linux

smc.c：源码内容
  1. /* -*- c-basic-offset: 2; tab-width: 8 -*-
  2.  * Based on nand_smc.c
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License version 2 as
  6.  * published by the Free Software Foundation.
  7.  *
  8.  */
  10. #include <linux/config.h>
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  14. #include <linux/delay.h>
  15. #include <linux/errno.h>
  16. #include <linux/sched.h>
  17. #include <linux/types.h>
  18. #include <linux/interrupt.h>
  19. #include <asm/io.h>
  21. #define CONFIG_MTD_DEBUG_VERBOSE 3
  22. #include <linux/mtd/mtd.h>
  23. #include <linux/mtd/nand.h>
  24. #include <linux/mtd/nand_ids.h>
  25. #include <linux/mtd/nand_ecc.h>
  27. /*
  28.  * Macros for low-level register control
  29.  */
  30. #define nand_select() this->hwcontrol(NAND_CTL_SETNCE); 
  31. nand_command(mtd, NAND_CMD_RESET, -1, -1); 
  32. udelay (10);
  33. #define nand_deselect() this->hwcontrol(NAND_CTL_CLRNCE);
  35. static inline void sm_swap(u_char *x, u_char *y) {
  36.     u_char tmp;
  37.     tmp = *x;
  38.     *x = *y;
  39.     *y = tmp;
  40. }
  42. /* define if you'll be using < 2M SMC device */
  43. #undef USE_256BYTE_NAND_FLASH
  45. /*
  46.  * Send command to NAND device
  47.  */
  48. static void nand_command (struct mtd_info *mtd, unsigned command,
  49. int column, int page_addr)
  50. {
  51. register struct nand_chip *this = mtd->priv;
  53. /* Begin command latch cycle */
  54. this->hwcontrol(NAND_CTL_SETCLE);
  56. this->hwcontrol(NAND_CTL_DAT_OUT);
  57. /*
  58.  * Write out the command to the device.
  59.  */
  60. if (command != NAND_CMD_SEQIN)
  61. this->write_cmd (command);
  62. else {
  63. if (mtd->oobblock == 256 && column >= 256) {
  64. column -= 256;
  65. this->write_cmd(NAND_CMD_RESET);
  66. this->write_cmd(NAND_CMD_READOOB);
  67. this->write_cmd(NAND_CMD_SEQIN);
  68. }
  69. else if (mtd->oobblock == 512 && column >= 256) {
  70. if (column < 512) {
  71. column -= 256;
  72. this->write_cmd(NAND_CMD_READ1);
  73. this->write_cmd(NAND_CMD_SEQIN);
  74. }
  75. else {
  76. column -= 512;
  77. this->write_cmd(NAND_CMD_READOOB);
  78. this->write_cmd(NAND_CMD_SEQIN);
  79. }
  80. }
  81. else {
  82. this->write_cmd(NAND_CMD_READ0);
  83. this->write_cmd(NAND_CMD_SEQIN);
  84. }
  85. }
  87. /* Set ALE and clear CLE to start address cycle */
  88. this->hwcontrol(NAND_CTL_CLRCLE);
  89. this->hwcontrol(NAND_CTL_SETALE);
  91. /* Serially input address */
  92. if (column != -1)
  93. this->write_addr (column);
  94. if (page_addr != -1) {
  95. this->write_addr ((u_char) (page_addr & 0xff));
  96. this->write_addr ((u_char) ((page_addr >> 8) & 0xff));
  97. /* One more address cycle for higher density devices */
  98. if (mtd->size & 0x0c000000) {
  99. this->write_addr ((u_char) ((page_addr >> 16) & 0x0f));
  100. }
  101. }
  103. /* Latch in address */
  104. this->hwcontrol(NAND_CTL_CLRALE);
  106. this->hwcontrol(NAND_CTL_DAT_IN);
  107. /* Pause for 15us */
  108. udelay (15);
  109. }
  111. /*
  112.  * NAND read
  113.  */
  114. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
  115. size_t *retlen, u_char *buf)
  116. {
  117. int j, col, page, state;
  118. int erase_state = 0;
  119. struct nand_chip *this = mtd->priv;
  120. DECLARE_WAITQUEUE(wait, current);
  122. DEBUG (MTD_DEBUG_LEVEL3,
  123. __FUNCTION__ ": from = 0x%08x, len = %in",
  124. (unsigned int) from, (int) len);
  126. /* Do not allow reads past end of device */
  127. if ((from + len) > mtd->size) {
  128. DEBUG (MTD_DEBUG_LEVEL0,
  129. __FUNCTION__ ": Attempt read beyond end of devicen");
  130. *retlen = 0;
  131. return -EINVAL;
  132. }
  134. /* Grab the lock and see if the device is available */
  135. retry:
  136. spin_lock_bh (&this->chip_lock);
  138. switch (this->state) {
  139. case FL_READY:
  140. this->state = FL_READING;
  141. spin_unlock_bh (&this->chip_lock);
  142. break;
  144. case FL_ERASING:
  145. this->state = FL_READING;
  146. erase_state = 1;
  147. spin_unlock_bh (&this->chip_lock);
  148. break;
  150. default:
  151. set_current_state (TASK_UNINTERRUPTIBLE);
  152. add_wait_queue (&this->wq, &wait);
  153. spin_unlock_bh (&this->chip_lock);
  154. schedule();
  156. remove_wait_queue (&this->wq, &wait);
  157. goto retry;
  158. };
  160. /* First we calculate the starting page */
  161. page = from >> this->page_shift;
  163. /* Get raw starting column */
  164. col = from & (mtd->oobblock - 1);
  166. /* State machine for devices having pages larger than 256 bytes */
  167. state = (col < mtd->eccsize) ? 0 : 1;
  169. /* Calculate column address within ECC block context */
  170. col = (col >= mtd->eccsize) ? (col - mtd->eccsize) : col;
  172. /* Initialize return value */
  173. *retlen = 0;
  175. /* Select the NAND device */
  176. nand_select ();
  178. /* Loop until all data read */
  179. while (*retlen < len) {
  181. /* Send the read command */
  182. if (!state)
  183. nand_command (mtd, NAND_CMD_READ0, col, page);
  184. else 
  185. nand_command (mtd, NAND_CMD_READ1, col, page);
  187. this->wait_for_ready();
  189. /* Read the data directly into the return buffer */ 
  190. if ((*retlen + (mtd->eccsize - col)) >= len) {
  191. while (*retlen < len)
  192. buf[(*retlen)++] = this->read_data();
  193. /* We're done */
  194. continue;
  195. }
  196. else
  197. for (j=col ; j < mtd->eccsize ; j++)
  198. buf[(*retlen)++] = this->read_data();
  200. /*
  201.  * If the amount of data to be read is greater than
  202.  * (256 - col), then all subsequent reads will take
  203.  * place on page or half-page (in the case of 512 byte
  204.  * page devices) aligned boundaries and the column
  205.  * address will be zero. Setting the column address to
  206.  * to zero after the first read allows us to simplify
  207.  * the reading of data and the if/else statements above.
  208.  */
  209. if (col)
  210. col = 0x00;
  212. /* Increment page address */
  213. if ((mtd->oobblock == 256) || state)
  214. page++;
  216. /* Toggle state machine */
  217. if (mtd->oobblock == 512)
  218. state = state ? 0 : 1;
  219. }
  221. /* De-select the NAND device */
  222. nand_deselect ();
  224. /* Wake up anyone waiting on the device */
  225. spin_lock_bh (&this->chip_lock);
  226. if (erase_state)
  227. this->state = FL_ERASING;
  228. else
  229. this->state = FL_READY;
  230. wake_up (&this->wq);
  231. spin_unlock_bh (&this->chip_lock);
  233. /* Return happy */
  234. return 0;
  235. }
  237. /*
  238.  * if mtd->oobblock == 512
  239.  */
  240. inline int smc_read_ecc_512(struct mtd_info *mtd, u_char *ecc_code)
  241. {
  242.     struct nand_chip *this = mtd->priv;
  243.     u_char ecc_calc[3];
  244.     int j, ret;
  246.     /* Read in a block big enough for ECC */
  247.     for (j=0; j < (mtd->oobblock + mtd->oobsize); j++)
  248.       this->data_buf[j] = this->read_data ();
  250. #if 0 /* for debugging, tolkien@mizi.com */
  251.     printk("Block + OOB");
  252.     for (j=0; j < (mtd->oobblock + mtd->oobsize); j++) {
  253.       if (j % 16 == 0)
  254. printk("n");
  255.       printk("%02x ", this->data_buf[j]);
  256.     }
  257.     printk("n");
  258. #endif
  260.     for (j=0; j < mtd->oobsize; j++)
  261.       ecc_code[j] = this->data_buf[(mtd->oobblock + j)];
  263. #if 0 /* for debugging, tolkien@mizi.com */
  264.     printk("OOB");
  265.     for (j=0; j < mtd->oobsize; j++) {
  266.       if (j % 16 == 0)
  267. printk("n");
  268.       printk("%02x ", this->data_buf[(mtd->oobblock + j)]);
  269.     }
  270.     printk("n");
  271. #endif
  272.     nand_calculate_ecc(&this->data_buf[0], &ecc_calc[0]);
  273.     sm_swap(&ecc_calc[0], &ecc_calc[1]);
  274.     DEBUG (MTD_DEBUG_LEVEL3,
  275.    __FUNCTION__ ": ECC [%02x%02x%02x : %02x%02x%02x]n",
  276.    ecc_code[SMC_OOB_ECC1], ecc_code[SMC_OOB_ECC1+1],
  277.    ecc_code[SMC_OOB_ECC1+2], ecc_calc[0], ecc_calc[1], ecc_calc[2]);
  278.     ret = nand_correct_data(&this->data_buf[0],
  279.     &(ecc_code[SMC_OOB_ECC1]), &ecc_calc[0]);
  280.     if (ret == -1)
  281.       return ret;
  283.     nand_calculate_ecc(&this->data_buf[mtd->eccsize], &ecc_calc[0]);
  284.     sm_swap(&ecc_calc[0], &ecc_calc[1]);
  285.     DEBUG (MTD_DEBUG_LEVEL3,
  286.    __FUNCTION__ ": ECC [%02x%02x%02x : %02x%02x%02x]n",
  287.    ecc_code[SMC_OOB_ECC2], ecc_code[SMC_OOB_ECC2+1],
  288.    ecc_code[SMC_OOB_ECC2+2], ecc_calc[0], ecc_calc[1], ecc_calc[2]);
  289.     ret = nand_correct_data(&this->data_buf[mtd->eccsize],
  290.     &(ecc_code[SMC_OOB_ECC2]), &ecc_calc[0]);
  291.     if (ret == -1)
  292.       return ret;
  294.     return 0;
  295. }
  297. /*
  298.  * NAND read with ECC
  299.  */
  300. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
  301. size_t *retlen, u_char *buf, u_char *ecc_code)
  302. {
  303.     int j, offset, page;
  304.     int erase_state = 0;
  305.     struct nand_chip *this = mtd->priv;
  306.     DECLARE_WAITQUEUE(wait, current);
  307.     int ret;
  309.     DEBUG (MTD_DEBUG_LEVEL3,
  310.    __FUNCTION__ ": from = 0x%08x, len = %in", (unsigned int) from,
  311.    (int) len);
  313.     /* Do not allow reads past end of device */
  314.     if ((from + len) > mtd->size) {
  315.       DEBUG (MTD_DEBUG_LEVEL0,
  316.      __FUNCTION__ ": Attempt read beyond end of devicen");
  317.       *retlen = 0;
  318.       return -EINVAL;
  319.     }
  321.     /* Grab the lock and see if the device is available */
  322.  retry:
  323.     spin_lock_bh (&this->chip_lock);
  325.     switch (this->state) {
  326.     case FL_READY:
  327.       this->state = FL_READING;
  328.       spin_unlock_bh (&this->chip_lock);
  329.       break;
  331.     case FL_ERASING:
  332.       this->state = FL_READING;
  333.       erase_state = 1;
  334.       spin_unlock_bh (&this->chip_lock);
  335.       break;
  337.     default:
  338.       set_current_state (TASK_UNINTERRUPTIBLE);
  339.       add_wait_queue (&this->wq, &wait);
  340.       spin_unlock_bh (&this->chip_lock);
  341.       schedule();
  343.       remove_wait_queue (&this->wq, &wait);
  344.       goto retry;
  345.     };
  347.     /* Select the NAND device */
  348.     nand_select ();
  350.     /* Initialize return value */
  351.     *retlen = 0;
  353. #ifdef USE_256BYTE_NAND_FLASH
  354.     /* First we calculate the starting page */
  355.     page = from >> this->page_shift;
  357.     /* Get raw starting column */
  358.     offset = from & (mtd->oobblock - 1);
  360.     /* if the length of Page is 256 bytes,
  361.        2 Pages must be taken for 1 Sector and as a result,
  362.        higher level 8 bytes of information
  363.        among the above 16 byte information must coincide with
  364.        Spare(or OOB) of Even-Page while lowel level 8 bytes
  365.        coincide with Spare(or OOB) of Odd-page.
  366.    i.e, [0 block][oob][1 block][oob]
  367. [2 block][oob][3 block][oob]...
  368.     */
  369.     if (mtd->oobblock == 256) {
  370. u_char ecc_calc[3];
  371. int oob_offset;
  373. /* Loop until all data read */
  374. while (*retlen < len) {
  375.   nand_command(mtd, NAND_CMD_READ0, 0x00, page);
  377.   this->wait_for_ready();
  379.   /* Read in a block big enough for ECC */
  380.   for(j=0; j < mtd->eccsize; j++)
  381.     this->data_buf[j] = this->read_data ();
  383.   if (!(page & 0x1)) { /* page is odd! */
  384.     nand_command (mtd, NAND_CMD_READOOB, SMC_OOB256_ECC1, page + 1);
  385.     oob_offset = SMC_OOB_ECC1;
  386.   } else {
  387.     nand_command (mtd, NAND_CMD_READOOB, SMC_OOB256_ECC2, page);
  388.     oob_offset = SMC_OOB_ECC2;
  389.   }
  391.   this->wait_for_ready();
  393.   for(j=0; j < 3; j++)
  394.     ecc_code[oob_offset + j] = this->read_data ();
  395.   nand_calculate_ecc (&this->data_buf[0], &ecc_calc[0]);
  396.   sm_swap(&ecc_calc[0], &ecc_calc[1]);
  397.   ret = nand_correct_data (&this->data_buf[0],
  398.    &(ecc_code[oob_offset]), &ecc_calc[0]);
  399.   if (ret == -1)
  400.     goto nand_read_ecc_err;
  402.   /* Read the data from ECC data buffer into return buffer */
  403.   if ((*retlen + (mtd->eccsize - offset)) >= len) {
  404.     while (*retlen < len)
  405.       buf[(*retlen)++] = this->data_buf[offset++];
  406.     /* We're done */
  407.     continue;
  408.   } else
  409.     for (j=offset ; j < mtd->eccsize ; j++)
  410.       buf[(*retlen)++] = this->data_buf[j];
  412.   /*
  413.    * If the amount of data to be read is greater than
  414.    * (256 - offset), then all subsequent reads will take
  415.    * place on page or half-page (in the case of 512 byte
  416.    * page devices) aligned boundaries and the column
  417.    * address will be zero. Setting the column address to
  418.    * to zero after the first read allows us to simplify
  419.    * the reading of data and the if/else statements above.
  420.    */
  421.   if (offset)
  422.     offset = 0x00;
  424.   /* Increment page address */
  425.   page++;
  426. }
  427.     }
  428.     else
  429. #endif /* USE_256BYTE_NAND_FLASH */
  430.     { /* mtd->oobblock == 512 */
  431.       size_t last, next, len2;
  433.       last = from + len;
  434.       for(next=from; from < last;) {
  435. page = from >> this->page_shift;
  436. offset = from & (mtd->oobblock - 1);
  437. len2 = mtd->oobblock - offset;
  438. next += len2;
  439. nand_command(mtd, NAND_CMD_READ0, 0x00, page);
  441. this->wait_for_ready();
  443. ret = smc_read_ecc_512(mtd, ecc_code);
  444. if (ret == -1)
  445.   goto nand_read_ecc_err;
  447. if (next >= last)
  448.   if ((last & (mtd->oobblock - 1)) != 0)
  449.     len2 = (last & (mtd->oobblock - 1)) - offset;
  451. for(j = 0; j < len2; j++)
  452.   buf[(*retlen) + j] = this->data_buf[offset + j];
  453. *retlen += len2;
  454. from = next;
  455.       }
  456.     }
  458.     ret = 0;
  459.     goto nand_read_ecc_exit;
  461.  nand_read_ecc_err:
  462.     DEBUG (MTD_DEBUG_LEVEL0,
  463.    __FUNCTION__ ": Failed ECC read, page 0x%08xn", page);
  464.     ret = -EIO;
  466.  nand_read_ecc_exit:
  467.     /* De-select the NAND device */
  468.     nand_deselect ();
  470.     /* Wake up anyone waiting on the device */
  471.     spin_lock_bh (&this->chip_lock);
  472.     if (erase_state)
  473.       this->state = FL_ERASING;
  474.     else
  475.       this->state = FL_READY;
  476.     wake_up (&this->wq);
  477.     spin_unlock_bh (&this->chip_lock);
  479.     return ret;
  480. }
  482. /*
  483.  * NAND read out-of-band
  484.  */
  485. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
  486. size_t *retlen, u_char *buf)
  487. {
  488. int i, offset, page;
  489. int erase_state = 0;
  490. struct nand_chip *this = mtd->priv;
  491. DECLARE_WAITQUEUE(wait, current);
  493. DEBUG (MTD_DEBUG_LEVEL3,
  494.        __FUNCTION__ ": from = 0x%08x, len = %in", (unsigned int) from,
  495.        (int) len);
  497. /* Shift to get page */
  498. page = ((int) from) >> this->page_shift;
  500. /* Mask to get column */
  501. offset = from & 0x0f;
  503. /* Initialize return length value */
  504. *retlen = 0;
  506. /* Do not allow read past end of page */
  507. if ((offset + len) > mtd->oobsize) {
  508. DEBUG (MTD_DEBUG_LEVEL0,
  509. __FUNCTION__ ": Attempt read past end of page " 
  510. "0x%08x, column %i, length %in", page, offset, len);
  511. return -EINVAL;
  512. }
  514. retry:
  515. /* Grab the lock and see if the device is available */
  516. spin_lock_bh (&this->chip_lock);
  518. switch (this->state) {
  519. case FL_READY:
  520. this->state = FL_READING;
  521. spin_unlock_bh (&this->chip_lock);
  522. break;
  524. case FL_ERASING:
  525. this->state = FL_READING;
  526. erase_state = 1;
  527. spin_unlock_bh (&this->chip_lock);
  528. break;
  530. default:
  531. set_current_state (TASK_UNINTERRUPTIBLE);
  532. add_wait_queue (&this->wq, &wait);
  533. spin_unlock_bh (&this->chip_lock);
  534. schedule();
  536. remove_wait_queue (&this->wq, &wait);
  537. goto retry;
  538. };
  540. /* Select the NAND device */
  541. nand_select ();
  543. /* Send the read command */
  544. nand_command (mtd, NAND_CMD_READOOB, offset, page);
  546. this->wait_for_ready();
  548. /* Read the data */
  549. for (i = 0 ; i < len ; i++)
  550. buf[i] = this->read_data();
  552. /* De-select the NAND device */
  553. nand_deselect ();
  555. /* Wake up anyone waiting on the device */
  556. spin_lock_bh (&this->chip_lock);
  557. if (erase_state)
  558. this->state = FL_ERASING;
  559. else
  560. this->state = FL_READY;
  561. wake_up (&this->wq);
  562. spin_unlock_bh (&this->chip_lock);
  564. /* Return happy */
  565. *retlen = len;
  566. return 0;
  567. }
  569. /*
  570.  * NAND write
  571.  */
  572. static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
  573.        size_t *retlen, const u_char *buf)
  574. {
  575.     int i, page, col, cnt, status;
  576.     struct nand_chip *this = mtd->priv;
  577.     DECLARE_WAITQUEUE(wait, current);
  579.     DEBUG (MTD_DEBUG_LEVEL3,
  580.    __FUNCTION__ ": to = 0x%08x, len = %in", (unsigned int) to,
  581.    (int) len);
  583.     /* Do not allow write past end of page */
  584.     if ((to + len) > mtd->size) {
  585.       DEBUG (MTD_DEBUG_LEVEL0,
  586.      __FUNCTION__ ": Attempted write past end of devicen");
  587.       return -EINVAL;
  588.     }
  590. retry:
  591.     /* Grab the lock and see if the device is available */
  592.     spin_lock_bh (&this->chip_lock);
  594.     switch (this->state) {
  595.     case FL_READY:
  596.       this->state = FL_WRITING;
  597.       spin_unlock_bh (&this->chip_lock);
  598.       break;
  600.     default:
  601.       set_current_state (TASK_UNINTERRUPTIBLE);
  602.       add_wait_queue (&this->wq, &wait);
  603.       spin_unlock_bh (&this->chip_lock);
  604.       schedule();
  606.       remove_wait_queue (&this->wq, &wait);
  607.       goto retry;
  608.     };
  610.     /* Shift to get page */
  611.     page = ((int) to) >> this->page_shift;
  613.     /* Get the starting column */
  614.     col = to & (mtd->oobblock - 1);
  616.     /* Initialize return length value */
  617.     *retlen = 0;
  619.     /* Select the NAND device */
  620.     nand_select ();
  622.     /* Check the WP bit */
  623.     nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  625.     this->wait_for_ready();
  627.     if (!(this->read_data () & SMC_STAT_NOT_WP)) {
  628.       DEBUG (MTD_DEBUG_LEVEL0,
  629.      __FUNCTION__ ": Device is write protected!!!n");
  630.       i = -EPERM;
  631.       goto nand_write_exit;
  632.     }
  634.     /* Loop until all data is written */
  635.     while (*retlen < len) {
  636.       /* Write data into buffer */
  637.       if ((col + len) >= mtd->oobblock)
  638. for(i=col, cnt=0 ; i < mtd->oobblock ; i++, cnt++)
  639.   this->data_buf[i] = buf[(*retlen + cnt)];
  640.       else
  641. for(i=col, cnt=0 ; cnt < (len - *retlen) ; i++, cnt++)
  642.   this->data_buf[i] = buf[(*retlen + cnt)];
  644.       /* Write ones for partial page programming */
  645.       for (i=mtd->oobblock ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  646. this->data_buf[i] = 0xff;
  648.       /* Write pre-padding bytes into buffer */
  649.       for (i=0 ; i < col ; i++)
  650. this->data_buf[i] = 0xff;
  652.       /* Write post-padding bytes into buffer */
  653.       if ((col + (len - *retlen)) < mtd->oobblock) {
  654. for(i=(col + cnt) ; i < mtd->oobblock ; i++)
  655.   this->data_buf[i] = 0xff;
  656.       }
  658.       /* Send command to begin auto page programming */
  659.       nand_command (mtd, NAND_CMD_SEQIN, 0x00, page);
  661.       /* Write out complete page of data */
  662.       this->hwcontrol(NAND_CTL_DAT_OUT);
  663.       for (i=0 ; i < (mtd->oobblock + mtd->oobsize) ; i++)
  664. this->write_data (this->data_buf[i]);
  665.       this->hwcontrol(NAND_CTL_DAT_IN);
  667.       /* Send command to actually program the data */
  668.       nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  670.       this->wait_for_ready();
  672.       /*
  673.        * Wait for program operation to complete. This could
  674.        * take up to 3000us (3ms) on some devices, so we try
  675.        * and exit as quickly as possible.
  676.        */
  677.       status = 0;
  678.       for (i=0 ; i<24 ; i++) {
  679. /* Delay for 125us */
  680. udelay (125);
  682. /* Check the status */
  683. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  684. status = (int) this->read_data ();
  685. if (status & SMC_STAT_READY)
  686.   break;
  687.       }
  689.       /* See if device thinks it succeeded */
  690.       if (status & SMC_STAT_WRITE_ERR) {
  691. DEBUG (MTD_DEBUG_LEVEL0,
  692.        __FUNCTION__ ": Failed write, page 0x%08x, " 
  693.        "%6i bytes were succesfuln", page, *retlen);
  694. i = -EIO;
  695. goto nand_write_exit;
  696.       }
  698. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  699.       /*
  700.        * The NAND device assumes that it is always writing to
  701.        * a cleanly erased page. Hence, it performs its internal
  702.        * write verification only on bits that transitioned from
  703.        * 1 to 0. The device does NOT verify the whole page on a
  704.        * byte by byte basis. It is possible that the page was
  705.        * not completely erased or the page is becoming unusable
  706.        * due to wear. The read with ECC would catch the error
  707.        * later when the ECC page check fails, but we would rather
  708.        * catch it early in the page write stage. Better to write
  709.        * no data than invalid data.
  710.        */
  712.       /* Send command to read back the page */
  713.       if (col < mtd->eccsize)
  714. nand_command (mtd, NAND_CMD_READ0, col, page);
  715.       else
  716. nand_command (mtd, NAND_CMD_READ1, col - 256, page);
  718.       this->wait_for_ready();
  720.       /* Loop through and verify the data */
  721.       for (i=col ; i < cnt ; i++) {
  722. if (this->data_buf[i] != this->read_data ()) {
  723.   DEBUG (MTD_DEBUG_LEVEL0,
  724.  __FUNCTION__ ": Failed write verify, page 0x%08x, " 
  725.  "%6i bytes were succesfuln",
  726.  page, *retlen);
  727.   i = -EIO;
  728.   goto nand_write_exit;
  729. }
  730.       }
  731. #endif
  733.       /*
  734.        * If we are writing a large amount of data and/or it
  735.        * crosses page or half-page boundaries, we set the
  736.        * the column to zero. It simplifies the program logic.
  737.        */
  738.       if (col)
  739. col = 0x00;
  741.       /* Update written bytes count */
  742.       *retlen += cnt;
  744.       /* Increment page address */
  745.       page++;
  746.     }
  748.     /* Return happy */
  749.     *retlen = len;
  750.     i = 0;
  752.  nand_write_exit:
  753.     /* De-select the NAND device */
  754.     nand_deselect ();
  756.     /* Wake up anyone waiting on the device */
  757.     spin_lock_bh (&this->chip_lock);
  758.     this->state = FL_READY;
  759.     wake_up (&this->wq);
  760.     spin_unlock_bh (&this->chip_lock);
  762.     return i;
  763. }
  765. /*
  766.  * NAND write with ECC, but only 1 sector!
  767.  */
  768. static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
  769.        size_t *retlen, const u_char *buf, u_char *ecc_code)
  770. {
  771.     int i, page, cnt, status, ret;
  772.     struct nand_chip *this = mtd->priv;
  773.     DECLARE_WAITQUEUE(wait, current);
  774.     unsigned int sector_size, page_size, oob_size;
  776.     DEBUG (MTD_DEBUG_LEVEL3,
  777.    __FUNCTION__ ": to = 0x%08x, len = %in", (unsigned int) to,
  778.    (int) len);
  780.     sector_size = this->dev->szS;
  781.     page_size = mtd->oobblock;
  782.     oob_size = mtd->oobsize;
  783.     if (to & (sector_size - 1)) {
  784.       DEBUG (MTD_DEBUG_LEVEL0,
  785.      __FUNCTION__ ": Not Sector alignedn");
  786.       return -EINVAL;
  787.     }
  788.     if (len != sector_size) {
  789.       DEBUG (MTD_DEBUG_LEVEL0,
  790.      __FUNCTION__ ": Only 1 Sector!n");
  791.       return -EINVAL;
  792.     }
  793.     /* Do not allow write past end of page */
  794.     if ((to + len) > mtd->size) {
  795.       DEBUG (MTD_DEBUG_LEVEL0,
  796.      __FUNCTION__ ": Attempted write past end of devicen");
  797.       return -EINVAL;
  798.     }
  800. retry:
  801.     /* Grab the lock and see if the device is available */
  802.     spin_lock_bh (&this->chip_lock);
  804.     switch (this->state) {
  805.     case FL_READY:
  806.       this->state = FL_WRITING;
  807.       spin_unlock_bh (&this->chip_lock);
  808.       break;
  810.     default:
  811.       set_current_state (TASK_UNINTERRUPTIBLE);
  812.       add_wait_queue (&this->wq, &wait);
  813.       spin_unlock_bh (&this->chip_lock);
  814.       schedule();
  816.       remove_wait_queue (&this->wq, &wait);
  817.       goto retry;
  818.     };
  820.     /* Shift to get page */
  821.     page = ((int) to) >> this->page_shift;
  823.     /* Initialize return length value */
  824.     *retlen = 0;
  826.     /* Select the NAND device */
  827.     nand_select ();
  829.     /* Check the WP bit */
  830.     nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  832.     this->wait_for_ready();
  834.     if (!(this->read_data () & SMC_STAT_NOT_WP)) {
  835.       DEBUG (MTD_DEBUG_LEVEL0,
  836.      __FUNCTION__ ": Device is write protected!!!n");
  837.       ret = -EPERM;
  838.       goto nand_write_err;
  839.     }
  841.     /* Loop until all data is written */
  842.     while (*retlen < len) {
  843.       /* Send command to begin auto page programming */
  844.       nand_command (mtd, NAND_CMD_SEQIN, 0x00, page);
  846.       this->hwcontrol(NAND_CTL_DAT_OUT);
  848.       /* Write out complete page of data */
  849.       for(i=0, cnt=0; i < page_size; i++, cnt++)
  850. this->write_data (buf[(*retlen) + cnt]);
  852.       /* Write ones for partial page programming */
  853.       for (i=0; i < oob_size; i++) {
  854. #ifdef USE_256BYTE_NAND_FLASH
  855. if (*retlen & (sector_size - 1))
  856.   this->write_data (ecc_code[SMC_OOB256_SIZE + i]);
  857. else
  858. #endif
  859.   this->write_data (ecc_code[i]);
  860.       }
  861.     
  862.       this->hwcontrol(NAND_CTL_DAT_IN);
  864.       /* Send command to actually program the data */
  865.       nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  867.       this->wait_for_ready();
  869.       /*
  870.        * Wait for program operation to complete. This could
  871.        * take up to 3000us (3ms) on some devices, so we try
  872.        * and exit as quickly as possible.
  873.        */
  874.       status = 0;
  875.       for (i=0 ; i<24 ; i++) {
  876. /* Delay for 125us */
  877. udelay (125);
  879. /* Check the status */
  880. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  881. status = (int) this->read_data ();
  882. if (status & SMC_STAT_READY)
  883.   break;
  884.       }
  886.       /* See if device thinks it succeeded */
  887.       if (status & SMC_STAT_WRITE_ERR) {
  888. DEBUG (MTD_DEBUG_LEVEL0,
  889.        __FUNCTION__ ": Failed write, page 0x%08x, " 
  890.        "%6i bytes were succesfuln", page, *retlen);
  891. ret = -EIO;
  892. goto nand_write_err;
  893.       }
  895. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  896.       /*
  897.        * The NAND device assumes that it is always writing to
  898.        * a cleanly erased page. Hence, it performs its internal
  899.        * write verification only on bits that transitioned from
  900.        * 1 to 0. The device does NOT verify the whole page on a
  901.        * byte by byte basis. It is possible that the page was
  902.        * not completely erased or the page is becoming unusable
  903.        * due to wear. The read with ECC would catch the error
  904.        * later when the ECC page check fails, but we would rather
  905.        * catch it early in the page write stage. Better to write
  906.        * no data than invalid data.
  907.        */
  909.       /* Send command to read back the page */
  910. #ifdef USE_256BYTE_NAND_FLASH
  911.       if (*retlen & (sector_size - 1))
  912. nand_command (mtd, NAND_CMD_READ0, 0x00, page + 1);
  913.       else
  914. #endif
  915. nand_command (mtd, NAND_CMD_READ0, 0x00, page);
  917.       this->wait_for_ready();
  919.       /* Loop through and verify the data */
  920.       for (i=0; i < page_size; i++) {
  921. if (this->data_buf[i] != this->read_data ()) {
  922.   DEBUG (MTD_DEBUG_LEVEL0,
  923.  __FUNCTION__ ": Failed write verify, page 0x%08x, " 
  924.  "%6i bytes were succesfuln",
  925.  page, *retlen);
  926.   ret = -EIO;
  927.   goto nand_write_err;
  928. }
  929.       }
  930. #endif
  932.       /* Update written bytes count */
  933.       *retlen += cnt;
  935.       /* Increment page address */
  936.       page++;
  937.     }
  939.     *retlen = len;
  940.     ret = 0;
  942.  nand_write_err:
  943.     /* De-select the NAND device */
  944.     nand_deselect ();
  946.     /* Wake up anyone waiting on the device */
  947.     spin_lock_bh (&this->chip_lock);
  948.     this->state = FL_READY;
  949.     wake_up (&this->wq);
  950.     spin_unlock_bh (&this->chip_lock);
  952.     return ret;
  953. }
  955. /*
  956.  * NAND write out-of-band
  957.  */
  958. static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
  959. size_t *retlen, const u_char *buf)
  960. {
  961.     int i, offset, page, status, ret;
  962.     struct nand_chip *this = mtd->priv;
  963.     DECLARE_WAITQUEUE(wait, current);
  965.     DEBUG (MTD_DEBUG_LEVEL3,
  966.    __FUNCTION__ ": to = 0x%08x, len = %in", (unsigned int) to,
  967.    (int) len);
  969.     /* Shift to get page */
  970.     page = ((int) to) >> this->page_shift;
  972.     /* Mask to get column */
  973.     offset = to & 0x1f;
  975.     /* Initialize return length value */
  976.     *retlen = 0;
  978.     /* Do not allow write past end of page */
  979.     if ((offset + len) > mtd->oobsize) {
  980.       DEBUG (MTD_DEBUG_LEVEL0,
  981.      __FUNCTION__": Attempt to write past end of pagen");
  982.       return -EINVAL;
  983.     }
  985. retry:
  986.     /* Grab the lock and see if the device is available */
  987.     spin_lock_bh (&this->chip_lock);
  989.     switch (this->state) {
  990.     case FL_READY:
  991.       this->state = FL_WRITING;
  992.       spin_unlock_bh (&this->chip_lock);
  993.       break;
  995.     default:
  996.       set_current_state (TASK_UNINTERRUPTIBLE);
  997.       add_wait_queue (&this->wq, &wait);
  998.       spin_unlock_bh (&this->chip_lock);
  999.       schedule();
  1001.       remove_wait_queue (&this->wq, &wait);
  1002.       goto retry;
  1003.     };
  1005.     /* Select the NAND device */
  1006.     nand_select ();
  1008.     /* Check the WP bit */
  1009.     nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1011.     this->wait_for_ready();
  1013.     if (!(this->read_data () & SMC_STAT_NOT_WP)) {
  1014.       DEBUG (MTD_DEBUG_LEVEL0,
  1015.      __FUNCTION__ ": Device is write protected!!!n");
  1016.       ret = -EPERM;
  1017.       goto nand_write_oob_err;
  1018.     }
  1020.     /* Write out desired data */
  1021.     nand_command (mtd, NAND_CMD_SEQIN, offset + mtd->oobblock, page);
  1022.     this->hwcontrol(NAND_CTL_DAT_OUT);
  1023.     for (i=0 ; i<len ; i++)
  1024.       this->write_data (buf[i]);
  1025.     this->hwcontrol(NAND_CTL_DAT_IN);
  1027.     /* Send command to program the OOB data */
  1028.     nand_command (mtd, NAND_CMD_PAGEPROG, -1, -1);
  1030.     this->wait_for_ready();
  1031.  
  1032.     /*
  1033.      * Wait for program operation to complete. This could
  1034.      * take up to 3000us (3ms) on some devices, so we try
  1035.      * and exit as quickly as possible.
  1036.      */
  1037.     status = 0;
  1038.     for (i=0 ; i<24 ; i++) {
  1039.       /* Delay for 125us */
  1040.       udelay (125);
  1042.       /* Check the status */
  1043.       nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1045.       this->wait_for_ready();
  1047.       status = (int) this->read_data ();
  1048.       if (status & SMC_STAT_READY)
  1049. break;
  1050.     }
  1052.     /* See if device thinks it succeeded */
  1053.     if (status & SMC_STAT_WRITE_ERR) {
  1054.       DEBUG (MTD_DEBUG_LEVEL0,
  1055.      __FUNCTION__ ": Failed write, page 0x%08xn", page);
  1056.       ret = -EIO;
  1057.       goto nand_write_oob_err;
  1058.     }
  1060. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  1061.     /* Send command to read back the data */
  1062.     nand_command (mtd, NAND_CMD_READOOB, offset, page);
  1064.     this->wait_for_ready();
  1066.     /* Loop through and verify the data */
  1067.     for (i=0 ; i<len ; i++) {
  1068.       if (buf[i] != this->read_data ()) {
  1069. DEBUG (MTD_DEBUG_LEVEL0,
  1070.        __FUNCTION__ ": Failed write verify, page 0x%08xn", page);
  1071. ret = -EIO;
  1072. goto nand_write_oob_err;
  1073.       }
  1074.     }
  1075. #endif
  1077.     /* Return happy */
  1078.     *retlen = len;
  1079.     ret = 0;
  1081.  nand_write_oob_err:
  1082.     /* De-select the NAND device */
  1083.     nand_deselect ();
  1085.     /* Wake up anyone waiting on the device */
  1086.     spin_lock_bh (&this->chip_lock);
  1087.     this->state = FL_READY;
  1088.     wake_up (&this->wq);
  1089.     spin_unlock_bh (&this->chip_lock);
  1091.     return ret;
  1092. }
  1094. /*
  1095.  * NAND erase a block
  1096.  */
  1097. static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
  1098. {
  1099. int i, page, len, status, pages_per_block;
  1100. struct nand_chip *this = mtd->priv;
  1101. DECLARE_WAITQUEUE(wait, current);
  1103. DEBUG (MTD_DEBUG_LEVEL3,
  1104. __FUNCTION__ ": start = 0x%08x, len = %in",
  1105. (unsigned int) instr->addr, (unsigned int) instr->len);
  1107. /* Start address must align on block boundary */
  1108. if (instr->addr & (mtd->erasesize - 1)) {
  1109. DEBUG (MTD_DEBUG_LEVEL0,
  1110. __FUNCTION__ ": Unaligned addressn");
  1111. return -EINVAL;
  1112. }
  1114. /* Length must align on block boundary */
  1115. if (instr->len & (mtd->erasesize - 1)) {
  1116. DEBUG (MTD_DEBUG_LEVEL0,
  1117. __FUNCTION__ ": Length not block alignedn");
  1118. return -EINVAL;
  1119. }
  1121. /* Do not allow erase past end of device */
  1122. if ((instr->len + instr->addr) > mtd->size) {
  1123. DEBUG (MTD_DEBUG_LEVEL0,
  1124. __FUNCTION__ ": Erase past end of devicen");
  1125. return -EINVAL;
  1126. }
  1128. retry:
  1129. /* Grab the lock and see if the device is available */
  1130. spin_lock_bh (&this->chip_lock);
  1132. switch (this->state) {
  1133. case FL_READY:
  1134. this->state = FL_ERASING;
  1135. break;
  1137. default:
  1138. set_current_state (TASK_UNINTERRUPTIBLE);
  1139. add_wait_queue (&this->wq, &wait);
  1140. spin_unlock_bh (&this->chip_lock);
  1141. schedule();
  1143. remove_wait_queue (&this->wq, &wait);
  1144. goto retry;
  1145. };
  1147. /* Shift to get first page */
  1148. page = (int) (instr->addr >> this->page_shift);
  1150. /* Calculate pages in each block */
  1151. pages_per_block = mtd->erasesize / mtd->oobblock;
  1153. /* Select the NAND device */
  1154. nand_select ();
  1156. /* Check the WP bit */
  1157. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1159. this->wait_for_ready();
  1161. if (!(this->read_data () & SMC_STAT_NOT_WP)) {
  1162. DEBUG (MTD_DEBUG_LEVEL0,
  1163. __FUNCTION__ ": Device is write protected!!!n");
  1164. nand_deselect ();
  1165. this->state = FL_READY;
  1166. spin_unlock_bh (&this->chip_lock);
  1167. return -EIO;
  1168. }
  1170. /* Loop through the pages */
  1171. len = instr->len;
  1172. while (len) {
  1173. /* Send commands to erase a page */
  1174. nand_command(mtd, NAND_CMD_ERASE1, -1, page);
  1175. nand_command(mtd, NAND_CMD_ERASE2, -1, -1);
  1177. this->wait_for_ready();
  1179. /*
  1180.  * Wait for program operation to complete. This could
  1181.  * take up to 4000us (4ms) on some devices, so we try
  1182.  * and exit as quickly as possible.
  1183.  */
  1184. status = 0;
  1185. for (i=0 ; i<32 ; i++) {
  1186. /* Delay for 125us */
  1187. udelay (125);
  1189. /* Check the status */
  1190. nand_command (mtd, NAND_CMD_STATUS, -1, -1);
  1192. this->wait_for_ready();
  1194. status = (int) this->read_data ();
  1195. if (status & SMC_STAT_READY)
  1196. break;
  1197. }
  1199. /* See if block erase succeeded */
  1200. if (status & SMC_STAT_WRITE_ERR) {
  1201. DEBUG (MTD_DEBUG_LEVEL0, __FUNCTION__ 
  1202. ": Failed erase, page 0x%08xn", page);
  1203. nand_deselect ();
  1204. instr->state = MTD_ERASE_FAILED;
  1205. if (instr->callback)
  1206.   instr->callback (instr);
  1207. this->state = FL_READY;
  1208. spin_unlock_bh (&this->chip_lock);
  1209. return -EIO;
  1210. }
  1212. /* Increment page address and decrement length */
  1213. len -= mtd->erasesize;
  1214. page += pages_per_block;
  1216. /* Release the spin lock */
  1217. spin_unlock_bh (&this->chip_lock);
  1219. erase_retry:
  1220. /* Check the state and sleep if it changed */
  1221. spin_lock_bh (&this->chip_lock);
  1222. if (this->state == FL_ERASING) {
  1223. continue;
  1224. }
  1225. else {
  1226. set_current_state (TASK_UNINTERRUPTIBLE);
  1227. add_wait_queue (&this->wq, &wait);
  1228. spin_unlock_bh (&this->chip_lock);
  1229. schedule();
  1231. remove_wait_queue (&this->wq, &wait);
  1232. goto erase_retry;
  1233. }
  1234. }
  1235. spin_unlock_bh (&this->chip_lock);
  1237. /* De-select the NAND device */
  1238. nand_deselect ();
  1240. /* Do call back function */
  1241. instr->state = MTD_ERASE_DONE;
  1242. if (instr->callback)
  1243. instr->callback (instr);
  1245. /* The device is ready */
  1246. spin_lock_bh (&this->chip_lock);
  1247. this->state = FL_READY;
  1248. spin_unlock_bh (&this->chip_lock);
  1250. /* Return happy */
  1251. return 0;
  1252. }
  1254. /*
  1255.  * NAND sync
  1256.  */
  1257. static void nand_sync (struct mtd_info *mtd)
  1258. {
  1259. struct nand_chip *this = mtd->priv;
  1260. DECLARE_WAITQUEUE(wait, current);
  1262. DEBUG (MTD_DEBUG_LEVEL3, __FUNCTION__ ": calledn");
  1264. retry:
  1265. /* Grab the spinlock */
  1266. spin_lock_bh(&this->chip_lock);
  1268. /* See what's going on */
  1269. switch(this->state) {
  1270. case FL_READY:
  1271. case FL_SYNCING:
  1272. this->state = FL_SYNCING;
  1273. spin_unlock_bh (&this->chip_lock);
  1274. break;
  1276. default:
  1277. /* Not an idle state */
  1278. add_wait_queue (&this->wq, &wait);
  1279. spin_unlock_bh (&this->chip_lock);
  1280. schedule ();
  1282. remove_wait_queue (&this->wq, &wait);
  1283. goto retry;
  1284. }
  1286.         /* Lock the device */
  1287. spin_lock_bh (&this->chip_lock);
  1289. /* Set the device to be ready again */
  1290. if (this->state == FL_SYNCING) {
  1291. this->state = FL_READY;
  1292. wake_up (&this->wq);
  1293. }
  1295.         /* Unlock the device */
  1296. spin_unlock_bh (&this->chip_lock);
  1297. }
  1299. /*
  1300.  * Scan for the SMC device
  1301.  */
  1302. int smc_scan (struct mtd_info *mtd)
  1303. {
  1304. int i, nand_maf_id, nand_dev_id;
  1305. struct nand_chip *this = mtd->priv;
  1307. /* Select the device */
  1308. nand_select ();
  1310. /* Send the command for reading device ID */
  1311. nand_command (mtd, NAND_CMD_READID, 0x00, -1);
  1313. this->wait_for_ready();
  1315. /* Read manufacturer and device IDs */
  1316. nand_maf_id = this->read_data ();
  1317. nand_dev_id = this->read_data ();
  1319. /* Print and store flash device information */
  1320. for (i = 0; nand_flash_ids[i].name != NULL; i++) {
  1321. if (nand_maf_id == nand_flash_ids[i].manufacture_id &&
  1322.     nand_dev_id == nand_flash_ids[i].model_id) {
  1323. #ifdef USE_256BYTE_NAND_FLASH
  1324. if (!mtd->size) {
  1325. mtd->name = nand_flash_ids[i].name;
  1326. mtd->erasesize = nand_flash_ids[i].erasesize;
  1327. mtd->size = (1 << nand_flash_ids[i].chipshift);
  1328. mtd->eccsize = 256;
  1329. if (nand_flash_ids[i].page256) {
  1330. mtd->oobblock = 256;
  1331. mtd->oobsize = 8;
  1332. this->page_shift = 8;
  1333. }
  1334. else {
  1335. mtd->oobblock = 512;
  1336. mtd->oobsize = 16;
  1337. this->page_shift = 9;
  1338. }
  1339. this->dev = &nand_smc_info[GET_DI_NUM(nand_flash_ids[i].chipshift)];
  1340. }
  1341. #else
  1342. if (!(mtd->size) && !(nand_flash_ids[i].page256)) {
  1343.   mtd->name = nand_flash_ids[i].name;
  1344.   mtd->erasesize = nand_flash_ids[i].erasesize;
  1345.   mtd->size = (1 << nand_flash_ids[i].chipshift);
  1346.   mtd->eccsize = 256;
  1347.   mtd->oobblock = 512;
  1348.   mtd->oobsize = 16;
  1349.   this->page_shift = 9;
  1350.   this->dev = &nand_smc_info[GET_DI_NUM(nand_flash_ids[i].chipshift)];
  1351. }
  1352. #endif
  1353. printk (KERN_INFO "NAND device: Manufacture ID:" 
  1354. " 0x%02x, Chip ID: 0x%02x (%s)n",
  1355. nand_maf_id, nand_dev_id, mtd->name);
  1356. break;
  1357. }
  1358. }
  1360. /* Initialize state and spinlock */
  1361. this->state = FL_READY;
  1362. spin_lock_init(&this->chip_lock);
  1363. init_waitqueue_head(&(this->wq));
  1365. /* De-select the device */
  1366. nand_deselect ();
  1368. /* Print warning message for no device */
  1369. if (!mtd->size) {
  1370. printk (KERN_WARNING "No NAND device found!!!n");
  1371. return 1;
  1372. }
  1374. /* Fill in remaining MTD driver data */
  1375. mtd->type = MTD_NANDFLASH;
  1376. mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
  1377. mtd->module = THIS_MODULE;
  1378. mtd->ecctype = MTD_ECC_SW;
  1379. mtd->erase = nand_erase;
  1380. mtd->point = NULL;
  1381. mtd->unpoint = NULL;
  1382. mtd->read = nand_read;
  1383. mtd->write = nand_write;
  1384. mtd->read_ecc = nand_read_ecc;
  1385. mtd->write_ecc = nand_write_ecc;
  1386. mtd->read_oob = nand_read_oob;
  1387. mtd->write_oob = nand_write_oob;
  1388. mtd->readv = NULL;
  1389. mtd->writev = NULL;
  1390. mtd->sync = nand_sync;
  1391. mtd->lock = NULL;
  1392. mtd->unlock = NULL;
  1393. mtd->suspend = NULL;
  1394. mtd->resume = NULL;
  1396. /* Return happy */
  1397. return 0;
  1398. }
  1399. EXPORT_SYMBOL(smc_scan);
  1401. MODULE_LICENSE("GPL");
  1402. MODULE_AUTHOR("Yong-iL Joh <tolkien@mizi.com>");
  1403. MODULE_DESCRIPTION("S3C2410 NAND Flash");