yaffs_mtdif2.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffs_mtdif.c  NAND mtd wrapper functions.
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *   for Toby Churchill Ltd and Brightstar Engineering
   7  *
   8  * Created by Charles Manning <charles@aleph1.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15
  16 /* mtd interface for YAFFS2 */
  17
  18 const char *yaffs_mtdif2_c_version =
  19     "$Id: yaffs_mtdif2.c,v 1.13 2006-09-26 13:28:13 vwool Exp $";
  20
  21 #include "yportenv.h"
  22
  23
  24 #include "yaffs_mtdif2.h"
  25
  26 #include "linux/mtd/mtd.h"
  27 #include "linux/types.h"
  28 #include "linux/time.h"
  29
  30 #include "yaffs_packedtags2.h"
  31
  32 int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
  33                                       const __u8 * data,
  34                                       const yaffs_ExtendedTags * tags)
  35 {
  36         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
  37 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  38         struct mtd_oob_ops ops;
  39 #else
  40         size_t dummy;
  41 #endif
  42         int retval = 0;
  43
  44         loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
  45
  46         yaffs_PackedTags2 pt;
  47
  48         T(YAFFS_TRACE_MTD,
  49           (TSTR
  50            ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
  51             TENDSTR), chunkInNAND, data, tags));
  52
  53 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
  54         if (tags)
  55                 yaffs_PackTags2(&pt, tags);
  56         else
  57                 BUG(); /* both tags and data should always be present */
  58
  59         if (data) {
  60                 ops.mode = MTD_OOB_AUTO;
  61                 ops.ooblen = sizeof(pt);
  62                 ops.len = dev->nBytesPerChunk;
  63                 ops.ooboffs = 0;
  64                 ops.datbuf = (__u8 *)data;
  65                 ops.oobbuf = (void *)&pt;
  66                 retval = mtd->write_oob(mtd, addr, &ops);
  67         } else
  68                 BUG(); /* both tags and data should always be present */
  69 #else
  70         if (tags) {
  71                 yaffs_PackTags2(&pt, tags);
  72         }
  73
  74         if (data && tags) {
  75                 if (dev->useNANDECC)
  76                         retval =
  77                             mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
  78                                            &dummy, data, (__u8 *) & pt, NULL);
  79                 else
  80                         retval =
  81                             mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
  82                                            &dummy, data, (__u8 *) & pt, NULL);
  83         } else {
  84                 if (data)
  85                         retval =
  86                             mtd->write(mtd, addr, dev->nBytesPerChunk, &dummy,
  87                                        data);
  88                 if (tags)
  89                         retval =
  90                             mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
  91                                            (__u8 *) & pt);
  92
  93         }
  94 #endif
  95
  96         if (retval == 0)
  97                 return YAFFS_OK;
  98         else
  99                 return YAFFS_FAIL;
 100 }
 101
 102 int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
 103                                        __u8 * data, yaffs_ExtendedTags * tags)
 104 {
 105         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 106 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 107         struct mtd_oob_ops ops;
 108 #endif
 109         size_t dummy;
 110         int retval = 0;
 111
 112         loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
 113
 114         yaffs_PackedTags2 pt;
 115
 116         T(YAFFS_TRACE_MTD,
 117           (TSTR
 118            ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
 119             TENDSTR), chunkInNAND, data, tags));
 120
 121 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 122         if (data && !tags)
 123                 retval = mtd->read(mtd, addr, dev->nBytesPerChunk,
 124                                 &dummy, data);
 125         else if (tags) {
 126                 ops.mode = MTD_OOB_AUTO;
 127                 ops.ooblen = sizeof(pt);
 128                 ops.len = data ? dev->nBytesPerChunk : sizeof(pt);
 129                 ops.ooboffs = 0;
 130                 ops.datbuf = data;
 131                 ops.oobbuf = dev->spareBuffer;
 132                 retval = mtd->read_oob(mtd, addr, &ops);
 133         }
 134 #else
 135         if (data && tags) {
 136                 if (dev->useNANDECC) {
 137                         retval =
 138                             mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
 139                                           &dummy, data, dev->spareBuffer,
 140                                           NULL);
 141                 } else {
 142                         retval =
 143                             mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
 144                                           &dummy, data, dev->spareBuffer,
 145                                           NULL);
 146                 }
 147         } else {
 148                 if (data)
 149                         retval =
 150                             mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy,
 151                                       data);
 152                 if (tags)
 153                         retval =
 154                             mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
 155                                           dev->spareBuffer);
 156         }
 157 #endif
 158
 159         memcpy(&pt, dev->spareBuffer, sizeof(pt));
 160
 161         if (tags)
 162                 yaffs_UnpackTags2(tags, &pt);
 163
 164         if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
 165                 tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
 166
 167         if (retval == 0)
 168                 return YAFFS_OK;
 169         else
 170                 return YAFFS_FAIL;
 171 }
 172
 173 int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 174 {
 175         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 176         int retval;
 177         T(YAFFS_TRACE_MTD,
 178           (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo));
 179
 180         retval =
 181             mtd->block_markbad(mtd,
 182                                blockNo * dev->nChunksPerBlock *
 183                                dev->nBytesPerChunk);
 184
 185         if (retval == 0)
 186                 return YAFFS_OK;
 187         else
 188                 return YAFFS_FAIL;
 189
 190 }
 191
 192 int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
 193                             yaffs_BlockState * state, int *sequenceNumber)
 194 {
 195         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 196         int retval;
 197
 198         T(YAFFS_TRACE_MTD,
 199           (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo));
 200         retval =
 201             mtd->block_isbad(mtd,
 202                              blockNo * dev->nChunksPerBlock *
 203                              dev->nBytesPerChunk);
 204
 205         if (retval) {
 206                 T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
 207
 208                 *state = YAFFS_BLOCK_STATE_DEAD;
 209                 *sequenceNumber = 0;
 210         } else {
 211                 yaffs_ExtendedTags t;
 212                 nandmtd2_ReadChunkWithTagsFromNAND(dev,
 213                                                    blockNo *
 214                                                    dev->nChunksPerBlock, NULL,
 215                                                    &t);
 216
 217                 if (t.chunkUsed) {
 218                         *sequenceNumber = t.sequenceNumber;
 219                         *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
 220                 } else {
 221                         *sequenceNumber = 0;
 222                         *state = YAFFS_BLOCK_STATE_EMPTY;
 223                 }
 224         }
 225         T(YAFFS_TRACE_MTD,
 226           (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber,
 227            *state));
 228
 229         if (retval == 0)
 230                 return YAFFS_OK;
 231         else
 232                 return YAFFS_FAIL;
 233 }
 234