projects / yaffs2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
yaffs Fixed some more bugs in direct/timothy_tests/mirror_tests
[yaffs2.git] / patches / yaffs_mtdif2.c
diff --git a/patches/yaffs_mtdif2.c b/patches/yaffs_mtdif2.c
index bc6fc705667faa3094cfc81698cf127ac131b243..19677ad47afd524d93a7be86f913a3b75da3ff94 100644 (file)
--- a/patches/yaffs_mtdif2.c
+++ b/patches/yaffs_mtdif2.c
@@ -1,8 +1,7 @@
 /*
  * YAFFS: Yet another FFS. A NAND-flash specific file system. 
 /*
  * YAFFS: Yet another FFS. A NAND-flash specific file system. 
- * yaffs_mtdif.c  NAND mtd wrapper functions.
  *
  *
- * Copyright (C) 2002 Aleph One Ltd.
+ * Copyright (C) 2002-2010 Aleph One Ltd.
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
  *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
@@ -10,13 +9,12 @@
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
- *
  */
 
 /* mtd interface for YAFFS2 */
 
 const char *yaffs_mtdif2_c_version =
  */
 
 /* mtd interface for YAFFS2 */
 
 const char *yaffs_mtdif2_c_version =
-    "$Id: yaffs_mtdif2.c,v 1.1 2006-05-25 01:37:27 charles Exp $";
+    "$Id: yaffs_mtdif2.c,v 1.2 2007-03-07 08:05:58 colin Exp $";
 
 #include "yportenv.h"
 
 
 #include "yportenv.h"
 
@@ -30,10 +28,10 @@ const char *yaffs_mtdif2_c_version =
 #include "yaffs_packedtags2.h"
 
 
 #include "yaffs_packedtags2.h"
 
 
-void nandmtd2_pt2buf(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw)
+void nandmtd2_pt2buf(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-       __u8 *ptab = (__u8 *)pt; /* packed tags as bytes */
+       u8 *ptab = (u8 *)pt; /* packed tags as bytes */
        
        int     i, j = 0, k, n;
 
        
        int     i, j = 0, k, n;
 
@@ -71,11 +69,11 @@ void nandmtd2_pt2buf(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw)
 
 }
 
 
 }
 
-void nandmtd2_buf2pt(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw)
+void nandmtd2_buf2pt(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int     i, j = 0, k, n;
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int     i, j = 0, k, n;
-       __u8 *ptab = (__u8 *)pt; /* packed tags as bytes */
+       u8 *ptab = (u8 *)pt; /* packed tags as bytes */
 
 
        if (!is_raw) {
 
 
        if (!is_raw) {
@@ -109,22 +107,22 @@ void nandmtd2_buf2pt(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw)
                
 }
 
                
 }
 
-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
-                                     const __u8 * data,
-                                     const yaffs_ExtendedTags * tags)
+int nandmtd2_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
+                                     const u8 * data,
+                                     const struct yaffs_ext_tags * tags)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
        int retval = 0;
 
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
        int retval = 0;
 
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+       loff_t addr = ((loff_t) nand_chunk) * dev->n_bytesPerChunk;
 
        yaffs_PackedTags2 pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
 
        yaffs_PackedTags2 pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
-           TENDSTR), chunkInNAND, data, tags));
+           TENDSTR), nand_chunk, data, tags));
 
        if (tags) {
                yaffs_PackTags2(&pt, tags);
 
        if (tags) {
                yaffs_PackTags2(&pt, tags);
@@ -133,7 +131,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
        if (data && tags) {
                        nandmtd2_pt2buf(dev, &pt, 0);
                        retval =
        if (data && tags) {
                        nandmtd2_pt2buf(dev, &pt, 0);
                        retval =
-                           mtd->write_ecc(mtd, addr, dev->nBytesPerChunk,
+                           mtd->write_ecc(mtd, addr, dev->n_bytesPerChunk,
                                           &dummy, data, dev->spareBuffer,
                                           NULL);
 
                                           &dummy, data, dev->spareBuffer,
                                           NULL);
 
@@ -151,32 +149,32 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
                return YAFFS_FAIL;
 }
 
                return YAFFS_FAIL;
 }
 
-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-                                      __u8 * data, yaffs_ExtendedTags * tags)
+int nandmtd2_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk,
+                                      u8 * data, struct yaffs_ext_tags * tags)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
        int retval = 0;
 
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
        int retval = 0;
 
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
+       loff_t addr = ((loff_t) nand_chunk) * dev->n_bytesPerChunk;
 
        yaffs_PackedTags2 pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_ReadChunkWithTagsToNAND chunk %d data %p tags %p"
 
        yaffs_PackedTags2 pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
           ("nandmtd2_ReadChunkWithTagsToNAND chunk %d data %p tags %p"
-           TENDSTR), chunkInNAND, data, tags));
+           TENDSTR), nand_chunk, data, tags));
 
        if (0 && data && tags) {
                        retval =
 
        if (0 && data && tags) {
                        retval =
-                           mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
+                           mtd->read_ecc(mtd, addr, dev->n_bytesPerChunk,
                                          &dummy, data, dev->spareBuffer,
                                          NULL);
                        nandmtd2_buf2pt(dev, &pt, 0);
        } else {
                if (data)
                        retval =
                                          &dummy, data, dev->spareBuffer,
                                          NULL);
                        nandmtd2_buf2pt(dev, &pt, 0);
        } else {
                if (data)
                        retval =
-                           mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy,
+                           mtd->read(mtd, addr, dev->n_bytesPerChunk, &dummy,
                                      data);
                if (tags) {
                        retval =
                                      data);
                if (tags) {
                        retval =
@@ -187,7 +185,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
        }
 
        if (tags)
        }
 
        if (tags)
-               yaffs_UnpackTags2(tags, &pt);
+               yaffs_unpack_tags2(tags, &pt);
 
        if (retval == 0)
                return YAFFS_OK;
 
        if (retval == 0)
                return YAFFS_OK;
@@ -195,17 +193,17 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
                return YAFFS_FAIL;
 }
 
                return YAFFS_FAIL;
 }
 
-int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int retval;
        T(YAFFS_TRACE_MTD,
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int retval;
        T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo));
+         (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), block_no));
 
        retval =
            mtd->block_markbad(mtd,
 
        retval =
            mtd->block_markbad(mtd,
-                              blockNo * dev->nChunksPerBlock *
-                              dev->nBytesPerChunk);
+                              block_no * dev->chunks_per_block *
+                              dev->n_bytesPerChunk);
 
        if (retval == 0)
                return YAFFS_OK;
 
        if (retval == 0)
                return YAFFS_OK;
@@ -214,41 +212,41 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 
 }
 
 
 }
 
-int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-                           yaffs_BlockState * state, int *sequenceNumber)
+int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
+                           enum yaffs_block_state * state, int *seq_number)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int retval;
 
        T(YAFFS_TRACE_MTD,
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int retval;
 
        T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo));
+         (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), block_no));
        retval =
            mtd->block_isbad(mtd,
        retval =
            mtd->block_isbad(mtd,
-                            blockNo * dev->nChunksPerBlock *
-                            dev->nBytesPerChunk);
+                            block_no * dev->chunks_per_block *
+                            dev->n_bytesPerChunk);
 
        if (retval) {
                T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
 
                *state = YAFFS_BLOCK_STATE_DEAD;
 
        if (retval) {
                T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
 
                *state = YAFFS_BLOCK_STATE_DEAD;
-               *sequenceNumber = 0;
+               *seq_number = 0;
        } else {
        } else {
-               yaffs_ExtendedTags t;
+               struct yaffs_ext_tags t;
                nandmtd2_ReadChunkWithTagsFromNAND(dev,
                nandmtd2_ReadChunkWithTagsFromNAND(dev,
-                                                  blockNo *
-                                                  dev->nChunksPerBlock, NULL,
+                                                  block_no *
+                                                  dev->chunks_per_block, NULL,
                                                   &t);
 
                                                   &t);
 
-               if (t.chunkUsed) {
-                       *sequenceNumber = t.sequenceNumber;
+               if (t.chunk_used) {
+                       *seq_number = t.seq_number;
                        *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
                } else {
                        *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
                } else {
-                       *sequenceNumber = 0;
+                       *seq_number = 0;
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
 
                T(YAFFS_TRACE_MTD,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
 
                T(YAFFS_TRACE_MTD,
-                 (TSTR("block is OK seq %d state %d" TENDSTR), *sequenceNumber,
+                 (TSTR("block is OK seq %d state %d" TENDSTR), *seq_number,
                   *state));
        }
 
                   *state));
        }
 
The YAFFS2 repository.