projects / yaffs2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
yaffs Further name changes and file reorganisation
[yaffs2.git] / yaffs_mtdif2.c
diff --git a/yaffs_mtdif2.c b/yaffs_mtdif2.c
index c6ebdaa70386df2f2956918b1ea71e3361ac2953..1c60a444ca8597c2896f232760aa9913ab01167a 100644 (file)
--- a/yaffs_mtdif2.c
+++ b/yaffs_mtdif2.c
@@ -27,10 +27,10 @@
 #include "yaffs_linux.h"
 
 /* NB For use with inband tags....
- * We assume that the data buffer is of size totalBytersPerChunk so that we can also
+ * We assume that the data buffer is of size total_bytes_per_chunk so that we can also
  * use it to load the tags.
  */
-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk,
+int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                                      const __u8 *data,
                                      const yaffs_ext_tags *tags)
 {
@@ -44,14 +44,14 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk,
 
        loff_t addr;
 
-       yaffs_PackedTags2 pt;
+       yaffs_packed_tags2 pt;
 
        int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
        void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
-          ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
+          ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 
 
@@ -64,11 +64,11 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk,
        if (!data || !tags)
                BUG();
        else if (dev->param.inband_tags) {
-               yaffs_PackedTags2TagsPart *pt2tp;
-               pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->data_bytes_per_chunk);
-               yaffs_PackTags2TagsPart(pt2tp, tags);
+               yaffs_packed_tags2_tags_only *pt2tp;
+               pt2tp = (yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk);
+               yaffs_pack_tags2_tags_only(pt2tp, tags);
        } else
-               yaffs_PackTags2(&pt, tags, !dev->param.no_tags_ecc);
+               yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc);
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
        ops.mode = MTD_OOB_AUTO;
@@ -97,7 +97,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk,
+int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                                       __u8 *data, yaffs_ext_tags *tags)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
@@ -106,24 +106,24 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk,
 #endif
        size_t dummy;
        int retval = 0;
-       int localData = 0;
+       int local_data = 0;
 
        loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
 
-       yaffs_PackedTags2 pt;
+       yaffs_packed_tags2 pt;
 
        int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt);
        void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt;
 
        T(YAFFS_TRACE_MTD,
          (TSTR
-          ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
+          ("nandmtd2_read_chunk_tags chunk %d data %p tags %p"
            TENDSTR), nand_chunk, data, tags));
 
        if (dev->param.inband_tags) {
 
                if (!data) {
-                       localData = 1;
+                       local_data = 1;
                        data = yaffs_get_temp_buffer(dev, __LINE__);
                }
 
@@ -141,14 +141,14 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk,
                ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size;
                ops.ooboffs = 0;
                ops.datbuf = data;
-               ops.oobbuf = yaffs_dev_to_lc(dev)->spareBuffer;
+               ops.oobbuf = yaffs_dev_to_lc(dev)->spare_buffer;
                retval = mtd->read_oob(mtd, addr, &ops);
        }
 #else
        if (!dev->param.inband_tags && data && tags) {
 
                retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk,
-                                         &dummy, data, dev->spareBuffer,
+                                         &dummy, data, dev->spare_buffer,
                                          NULL);
        } else {
                if (data)
@@ -158,25 +158,25 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk,
                if (!dev->param.inband_tags && tags)
                        retval =
                            mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
-                                         dev->spareBuffer);
+                                         dev->spare_buffer);
        }
 #endif
 
 
        if (dev->param.inband_tags) {
                if (tags) {
-                       yaffs_PackedTags2TagsPart *pt2tp;
-                       pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk];
-                       yaffs_unpack_tags2tags_part(tags, pt2tp);
+                       yaffs_packed_tags2_tags_only *pt2tp;
+                       pt2tp = (yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk];
+                       yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
                if (tags) {
-                       memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spareBuffer, packed_tags_size);
+                       memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size);
                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }
 
-       if (localData)
+       if (local_data)
                yaffs_release_temp_buffer(dev, data, __LINE__);
 
        if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) {
@@ -193,12 +193,12 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
+int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
        T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), block_no));
+         (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
 
        retval =
            mtd->block_markbad(mtd,
@@ -212,14 +212,14 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
 
 }
 
-int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
+int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
                            yaffs_block_state_t *state, __u32 *seq_number)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
        T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), block_no));
+         (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
@@ -232,8 +232,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
                *seq_number = 0;
        } else {
                yaffs_ext_tags t;
-               nandmtd2_ReadChunkWithTagsFromNAND(dev,
-                                                  block_no *
+               nandmtd2_read_chunk_tags(dev, block_no *
                                                   dev->param.chunks_per_block, NULL,
                                                   &t);
 
The YAFFS2 repository.