yaffs_mtdif.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  1. /*
  2. * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  3. *
  4. * Copyright (C) 2002-2007 Aleph One Ltd.
  5. * for Toby Churchill Ltd and Brightstar Engineering
  6. *
  7. * Created by Charles Manning <charles@aleph1.co.uk>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. */
  13. const char *yaffs_mtdif_c_version =
  14. "$Id: yaffs_mtdif.c,v 1.1 2007/08/13 07:18:33 jsgood Exp $";
  15. #include "yportenv.h"
  16. #include "yaffs_mtdif.h"
  17. #include "linux/mtd/mtd.h"
  18. #include "linux/types.h"
  19. #include "linux/time.h"
  20. #include "linux/mtd/nand.h"
  21. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
  22. static struct nand_oobinfo yaffs_oobinfo = {
  23. .useecc = 1,
  24. .eccbytes = 6,
  25. .eccpos = {8, 9, 10, 13, 14, 15}
  26. };
  27. static struct nand_oobinfo yaffs_noeccinfo = {
  28. .useecc = 0,
  29. };
  30. #endif
  31. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  32. static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
  33. {
  34. oob[0] = spare->tagByte0;
  35. oob[1] = spare->tagByte1;
  36. oob[2] = spare->tagByte2;
  37. oob[3] = spare->tagByte3;
  38. oob[4] = spare->tagByte4;
  39. oob[5] = spare->tagByte5 & 0x3f;
  40. oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80;
  41. oob[5] |= spare->pageStatus == 0 ? 0: 0x40;
  42. oob[6] = spare->tagByte6;
  43. oob[7] = spare->tagByte7;
  44. }
  45. static inline void translate_oob2spare(yaffs_Spare *spare, __u8 *oob)
  46. {
  47. struct yaffs_NANDSpare *nspare = (struct yaffs_NANDSpare *)spare;
  48. spare->tagByte0 = oob[0];
  49. spare->tagByte1 = oob[1];
  50. spare->tagByte2 = oob[2];
  51. spare->tagByte3 = oob[3];
  52. spare->tagByte4 = oob[4];
  53. spare->tagByte5 = oob[5] == 0xff ? 0xff : oob[5] & 0x3f;
  54. spare->blockStatus = oob[5] & 0x80 ? 0xff : 'Y';
  55. spare->pageStatus = oob[5] & 0x40 ? 0xff : 0;
  56. spare->ecc1[0] = spare->ecc1[1] = spare->ecc1[2] = 0xff;
  57. spare->tagByte6 = oob[6];
  58. spare->tagByte7 = oob[7];
  59. spare->ecc2[0] = spare->ecc2[1] = spare->ecc2[2] = 0xff;
  60. nspare->eccres1 = nspare->eccres2 = 0; /* FIXME */
  61. }
  62. #endif
  63. int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
  64. const __u8 * data, const yaffs_Spare * spare)
  65. {
  66. struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
  67. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  68. struct mtd_oob_ops ops;
  69. #endif
  70. size_t dummy;
  71. int retval = 0;
  72. loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
  73. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  74. __u8 spareAsBytes[8]; /* OOB */
  75. if (data && !spare)
  76. retval = mtd->write(mtd, addr, dev->nDataBytesPerChunk,
  77. &dummy, data);
  78. else if (spare) {
  79. if (dev->useNANDECC) {
  80. translate_spare2oob(spare, spareAsBytes);
  81. ops.mode = MTD_OOB_AUTO;
  82. ops.ooblen = 8; /* temp hack */
  83. } else {
  84. ops.mode = MTD_OOB_RAW;
  85. ops.ooblen = YAFFS_BYTES_PER_SPARE;
  86. }
  87. ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
  88. ops.datbuf = (u8 *)data;
  89. ops.ooboffs = 0;
  90. ops.oobbuf = spareAsBytes;
  91. retval = mtd->write_oob(mtd, addr, &ops);
  92. }
  93. #else
  94. __u8 *spareAsBytes = (__u8 *) spare;
  95. if (data && spare) {
  96. if (dev->useNANDECC)
  97. retval =
  98. mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
  99. &dummy, data, spareAsBytes,
  100. &yaffs_oobinfo);
  101. else
  102. retval =
  103. mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
  104. &dummy, data, spareAsBytes,
  105. &yaffs_noeccinfo);
  106. } else {
  107. if (data)
  108. retval =
  109. mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
  110. data);
  111. if (spare)
  112. retval =
  113. mtd->write_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
  114. &dummy, spareAsBytes);
  115. }
  116. #endif
  117. if (retval == 0)
  118. return YAFFS_OK;
  119. else
  120. return YAFFS_FAIL;
  121. }
  122. int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
  123. yaffs_Spare * spare)
  124. {
  125. struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
  126. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  127. struct mtd_oob_ops ops;
  128. #endif
  129. size_t dummy;
  130. int retval = 0;
  131. loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
  132. #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  133. __u8 spareAsBytes[8]; /* OOB */
  134. if (data && !spare)
  135. retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
  136. &dummy, data);
  137. else if (spare) {
  138. if (dev->useNANDECC) {
  139. ops.mode = MTD_OOB_AUTO;
  140. ops.ooblen = 8; /* temp hack */
  141. } else {
  142. ops.mode = MTD_OOB_RAW;
  143. ops.ooblen = YAFFS_BYTES_PER_SPARE;
  144. }
  145. ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
  146. ops.datbuf = data;
  147. ops.ooboffs = 0;
  148. ops.oobbuf = spareAsBytes;
  149. retval = mtd->read_oob(mtd, addr, &ops);
  150. if (dev->useNANDECC)
  151. translate_oob2spare(spare, spareAsBytes);
  152. }
  153. #else
  154. __u8 *spareAsBytes = (__u8 *) spare;
  155. if (data && spare) {
  156. if (dev->useNANDECC) {
  157. /* Careful, this call adds 2 ints */
  158. /* to the end of the spare data. Calling function */
  159. /* should allocate enough memory for spare, */
  160. /* i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. */
  161. retval =
  162. mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
  163. &dummy, data, spareAsBytes,
  164. &yaffs_oobinfo);
  165. } else {
  166. retval =
  167. mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
  168. &dummy, data, spareAsBytes,
  169. &yaffs_noeccinfo);
  170. }
  171. } else {
  172. if (data)
  173. retval =
  174. mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
  175. data);
  176. if (spare)
  177. retval =
  178. mtd->read_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
  179. &dummy, spareAsBytes);
  180. }
  181. #endif
  182. if (retval == 0)
  183. return YAFFS_OK;
  184. else
  185. return YAFFS_FAIL;
  186. }
  187. int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
  188. {
  189. struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
  190. __u32 addr =
  191. ((loff_t) blockNumber) * dev->nDataBytesPerChunk
  192. * dev->nChunksPerBlock;
  193. struct erase_info ei;
  194. int retval = 0;
  195. ei.mtd = mtd;
  196. ei.addr = addr;
  197. ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock;
  198. ei.time = 1000;
  199. ei.retries = 2;
  200. ei.callback = NULL;
  201. ei.priv = (u_long) dev;
  202. /* Todo finish off the ei if required */
  203. sema_init(&dev->sem, 0);
  204. retval = mtd->erase(mtd, &ei);
  205. if (retval == 0)
  206. return YAFFS_OK;
  207. else
  208. return YAFFS_FAIL;
  209. }
  210. int nandmtd_InitialiseNAND(yaffs_Device * dev)
  211. {
  212. return YAFFS_OK;
  213. }