diff options
Diffstat (limited to 'target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c')
-rw-r--r-- | target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c | 380 |
1 files changed, 189 insertions, 191 deletions
diff --git a/target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c b/target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c index 402537f..c04a2fb 100644 --- a/target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c +++ b/target/linux/generic/files/fs/yaffs2/yaffs_tagscompat.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 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> @@ -15,19 +15,20 @@ #include "yaffs_tagscompat.h" #include "yaffs_ecc.h" #include "yaffs_getblockinfo.h" +#include "yaffs_trace.h" -static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND); +static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); #ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND); -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, +static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk); +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_Spare *spare); -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare); -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND); + const yaffs_spare *spare); +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_spare *spare); +static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk); #endif -static const char yaffs_countBitsTable[256] = { +static const char yaffs_count_bits_table[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, @@ -46,26 +47,26 @@ static const char yaffs_countBitsTable[256] = { 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; -int yaffs_CountBits(__u8 x) +int yaffs_count_bits(__u8 x) { int retVal; - retVal = yaffs_countBitsTable[x]; + retVal = yaffs_count_bits_table[x]; return retVal; } /********** Tags ECC calculations *********/ -void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare) +void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) { - yaffs_ECCCalculate(data, spare->ecc1); - yaffs_ECCCalculate(&data[256], spare->ecc2); + yaffs_ecc_cacl(data, spare->ecc1); + yaffs_ecc_cacl(&data[256], spare->ecc2); } -void yaffs_CalcTagsECC(yaffs_Tags *tags) +void yaffs_calc_tags_ecc(yaffs_tags_t *tags) { /* Calculate an ecc */ - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -84,24 +85,24 @@ void yaffs_CalcTagsECC(yaffs_Tags *tags) } -int yaffs_CheckECCOnTags(yaffs_Tags *tags) +int yaffs_check_tags_ecc(yaffs_tags_t *tags) { unsigned ecc = tags->ecc; - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); ecc ^= tags->ecc; if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; ecc--; b[ecc / 8] ^= (1 << (ecc & 7)); /* Now recvalc the ecc */ - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); return 1; /* recovered error */ } else if (ecc) { @@ -115,76 +116,73 @@ int yaffs_CheckECCOnTags(yaffs_Tags *tags) /********** Tags **********/ -static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, + yaffs_tags_t *tagsPtr) { - yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; - - yaffs_CalcTagsECC(tagsPtr); - - sparePtr->tagByte0 = tu->asBytes[0]; - sparePtr->tagByte1 = tu->asBytes[1]; - sparePtr->tagByte2 = tu->asBytes[2]; - sparePtr->tagByte3 = tu->asBytes[3]; - sparePtr->tagByte4 = tu->asBytes[4]; - sparePtr->tagByte5 = tu->asBytes[5]; - sparePtr->tagByte6 = tu->asBytes[6]; - sparePtr->tagByte7 = tu->asBytes[7]; + yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; + + yaffs_calc_tags_ecc(tagsPtr); + + sparePtr->tb0 = tu->as_bytes[0]; + sparePtr->tb1 = tu->as_bytes[1]; + sparePtr->tb2 = tu->as_bytes[2]; + sparePtr->tb3 = tu->as_bytes[3]; + sparePtr->tb4 = tu->as_bytes[4]; + sparePtr->tb5 = tu->as_bytes[5]; + sparePtr->tb6 = tu->as_bytes[6]; + sparePtr->tb7 = tu->as_bytes[7]; } -static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *sparePtr, + yaffs_tags_t *tagsPtr) { - yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; + yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; int result; - tu->asBytes[0] = sparePtr->tagByte0; - tu->asBytes[1] = sparePtr->tagByte1; - tu->asBytes[2] = sparePtr->tagByte2; - tu->asBytes[3] = sparePtr->tagByte3; - tu->asBytes[4] = sparePtr->tagByte4; - tu->asBytes[5] = sparePtr->tagByte5; - tu->asBytes[6] = sparePtr->tagByte6; - tu->asBytes[7] = sparePtr->tagByte7; + tu->as_bytes[0] = sparePtr->tb0; + tu->as_bytes[1] = sparePtr->tb1; + tu->as_bytes[2] = sparePtr->tb2; + tu->as_bytes[3] = sparePtr->tb3; + tu->as_bytes[4] = sparePtr->tb4; + tu->as_bytes[5] = sparePtr->tb5; + tu->as_bytes[6] = sparePtr->tb6; + tu->as_bytes[7] = sparePtr->tb7; - result = yaffs_CheckECCOnTags(tagsPtr); + result = yaffs_check_tags_ecc(tagsPtr); if (result > 0) - dev->tagsEccFixed++; + dev->n_tags_ecc_fixed++; else if (result < 0) - dev->tagsEccUnfixed++; + dev->n_tags_ecc_unfixed++; } -static void yaffs_SpareInitialise(yaffs_Spare *spare) +static void yaffs_spare_init(yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_Spare)); + memset(spare, 0xFF, sizeof(yaffs_spare)); } -static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - yaffs_Spare *spare) +static int yaffs_wr_nand(struct yaffs_dev_s *dev, + int nand_chunk, const __u8 *data, + yaffs_spare *spare) { - if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) { + if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - chunkInNAND)); + nand_chunk)); return YAFFS_FAIL; } - dev->nPageWrites++; - return dev->writeChunkToNAND(dev, chunkInNAND, data, spare); + return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } -static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, +static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, + int nand_chunk, __u8 *data, - yaffs_Spare *spare, - yaffs_ECCResult *eccResult, + yaffs_spare *spare, + yaffs_ecc_result *ecc_result, int doErrorCorrection) { int retVal; - yaffs_Spare localSpare; - - dev->nPageReads++; + yaffs_spare localSpare; if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ @@ -192,107 +190,107 @@ static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, spare = &localSpare; } - if (!dev->useNANDECC) { - retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare); + if (!dev->param.use_nand_ecc) { + retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && doErrorCorrection) { /* Do ECC correction */ /* Todo handle any errors */ - int eccResult1, eccResult2; + int ecc_result1, ecc_result2; __u8 calcEcc[3]; - yaffs_ECCCalculate(data, calcEcc); - eccResult1 = - yaffs_ECCCorrect(data, spare->ecc1, calcEcc); - yaffs_ECCCalculate(&data[256], calcEcc); - eccResult2 = - yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc); + yaffs_ecc_cacl(data, calcEcc); + ecc_result1 = + yaffs_ecc_correct(data, spare->ecc1, calcEcc); + yaffs_ecc_cacl(&data[256], calcEcc); + ecc_result2 = + yaffs_ecc_correct(&data[256], spare->ecc2, calcEcc); - if (eccResult1 > 0) { + if (ecc_result1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult1 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult2 > 0) { + if (ecc_result2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult2 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult1 || eccResult2) { + if (ecc_result1 || ecc_result2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } - if (eccResult1 < 0 || eccResult2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; - else if (eccResult1 > 0 || eccResult2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + if (ecc_result1 < 0 || ecc_result2 < 0) + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (ecc_result1 > 0 || ecc_result2 > 0) + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } else { /* Must allocate enough memory for spare+2*sizeof(int) */ /* for ecc results from device. */ - struct yaffs_NANDSpare nspare; + struct yaffs_nand_spare nspare; memset(&nspare, 0, sizeof(nspare)); - retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, - (yaffs_Spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_Spare)); + retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, + (yaffs_spare *) &nspare); + memcpy(spare, &nspare, sizeof(yaffs_spare)); if (data && doErrorCorrection) { if (nspare.eccres1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres1 || nspare.eccres2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } if (nspare.eccres1 < 0 || nspare.eccres2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } @@ -300,17 +298,17 @@ static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, } #ifdef NOTYET -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) +static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, + int nand_chunk) { static int init; static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; static __u8 data[YAFFS_BYTES_PER_CHUNK]; /* Might as well always allocate the larger size for */ - /* dev->useNANDECC == true; */ - static __u8 spare[sizeof(struct yaffs_NANDSpare)]; + /* dev->param.use_nand_ecc == true; */ + static __u8 spare[sizeof(struct yaffs_nand_spare)]; - dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); + dev->param.read_chunk_fn(dev, nand_chunk, data, (yaffs_spare *) spare); if (!init) { memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); @@ -331,14 +329,14 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, * Functions for robustisizing */ -static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) +static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1; + yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); + (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); /* TODO: * Just do a garbage collection on the affected block @@ -348,44 +346,44 @@ static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) } #ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND) +static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk) { } -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_Spare *spare) + const yaffs_spare *spare) { } -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare) +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_spare *spare) { } -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND) +static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; + yaffs_get_block_info(dev, flash_block)->needs_retiring = 1; /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); } -static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1, - const yaffs_Spare *s0, const yaffs_Spare *s1) +static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, + const yaffs_spare *s0, const yaffs_spare *s1) { if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || - s0->tagByte0 != s1->tagByte0 || - s0->tagByte1 != s1->tagByte1 || - s0->tagByte2 != s1->tagByte2 || - s0->tagByte3 != s1->tagByte3 || - s0->tagByte4 != s1->tagByte4 || - s0->tagByte5 != s1->tagByte5 || - s0->tagByte6 != s1->tagByte6 || - s0->tagByte7 != s1->tagByte7 || + s0->tb0 != s1->tb0 || + s0->tb1 != s1->tb1 || + s0->tb2 != s1->tb2 || + s0->tb3 != s1->tb3 || + s0->tb4 != s1->tb4 || + s0->tb5 != s1->tb5 || + s0->tb6 != s1->tb6 || + s0->tb7 != s1->tb7 || s0->ecc1[0] != s1->ecc1[0] || s0->ecc1[1] != s1->ecc1[1] || s0->ecc1[2] != s1->ecc1[2] || @@ -398,53 +396,53 @@ static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1, } #endif /* NOTYET */ -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, +int yaffs_tags_compat_wr(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *eTags) + const yaffs_ext_tags *eTags) { - yaffs_Spare spare; - yaffs_Tags tags; + yaffs_spare spare; + yaffs_tags_t tags; - yaffs_SpareInitialise(&spare); + yaffs_spare_init(&spare); - if (eTags->chunkDeleted) - spare.pageStatus = 0; + if (eTags->is_deleted) + spare.page_status = 0; else { - tags.objectId = eTags->objectId; - tags.chunkId = eTags->chunkId; + tags.obj_id = eTags->obj_id; + tags.chunk_id = eTags->chunk_id; - tags.byteCountLSB = eTags->byteCount & 0x3ff; + tags.n_bytes_lsb = eTags->n_bytes & 0x3ff; - if (dev->nDataBytesPerChunk >= 1024) - tags.byteCountMSB = (eTags->byteCount >> 10) & 3; + if (dev->data_bytes_per_chunk >= 1024) + tags.n_bytes_msb = (eTags->n_bytes >> 10) & 3; else - tags.byteCountMSB = 3; + tags.n_bytes_msb = 3; - tags.serialNumber = eTags->serialNumber; + tags.serial_number = eTags->serial_number; - if (!dev->useNANDECC && data) - yaffs_CalcECC(data, &spare); + if (!dev->param.use_nand_ecc && data) + yaffs_calc_ecc(data, &spare); - yaffs_LoadTagsIntoSpare(&spare, &tags); + yaffs_load_tags_to_spare(&spare, &tags); } - return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare); + return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, +int yaffs_tags_compat_rd(yaffs_dev_t *dev, + int nand_chunk, __u8 *data, - yaffs_ExtendedTags *eTags) + yaffs_ext_tags *eTags) { - yaffs_Spare spare; - yaffs_Tags tags; - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN; + yaffs_spare spare; + yaffs_tags_t tags; + yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - static yaffs_Spare spareFF; + static yaffs_spare spareFF; static int init; if (!init) { @@ -452,33 +450,33 @@ int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, init = 1; } - if (yaffs_ReadChunkFromNAND - (dev, chunkInNAND, data, &spare, &eccResult, 1)) { + if (yaffs_rd_chunk_nand + (dev, nand_chunk, data, &spare, &ecc_result, 1)) { /* eTags may be NULL */ if (eTags) { int deleted = - (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0; + (yaffs_count_bits(spare.page_status) < 7) ? 1 : 0; - eTags->chunkDeleted = deleted; - eTags->eccResult = eccResult; - eTags->blockBad = 0; /* We're reading it */ + eTags->is_deleted = deleted; + eTags->ecc_result = ecc_result; + eTags->block_bad = 0; /* We're reading it */ /* therefore it is not a bad block */ - eTags->chunkUsed = + eTags->chunk_used = (memcmp(&spareFF, &spare, sizeof(spareFF)) != 0) ? 1 : 0; - if (eTags->chunkUsed) { - yaffs_GetTagsFromSpare(dev, &spare, &tags); + if (eTags->chunk_used) { + yaffs_get_tags_from_spare(dev, &spare, &tags); - eTags->objectId = tags.objectId; - eTags->chunkId = tags.chunkId; - eTags->byteCount = tags.byteCountLSB; + eTags->obj_id = tags.obj_id; + eTags->chunk_id = tags.chunk_id; + eTags->n_bytes = tags.n_bytes_lsb; - if (dev->nDataBytesPerChunk >= 1024) - eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10); + if (dev->data_bytes_per_chunk >= 1024) + eTags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); - eTags->serialNumber = tags.serialNumber; + eTags->serial_number = tags.serial_number; } } @@ -488,49 +486,49 @@ int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, } } -int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, + int flash_block) { - yaffs_Spare spare; + yaffs_spare spare; - memset(&spare, 0xff, sizeof(yaffs_Spare)); + memset(&spare, 0xff, sizeof(yaffs_spare)); - spare.blockStatus = 'Y'; + spare.block_status = 'Y'; - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL, + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, &spare); - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1, + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, NULL, &spare); return YAFFS_OK; } -int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber) +int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, + int block_no, + yaffs_block_state_t *state, + __u32 *seq_number) { - yaffs_Spare spare0, spare1; - static yaffs_Spare spareFF; + yaffs_spare spare0, spare1; + static yaffs_spare spareFF; static int init; - yaffs_ECCResult dummy; + yaffs_ecc_result dummy; if (!init) { memset(&spareFF, 0xFF, sizeof(spareFF)); init = 1; } - *sequenceNumber = 0; + *seq_number = 0; - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL, + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, &spare0, &dummy, 1); - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL, + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, &spare1, &dummy, 1); - if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) + if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) *state = YAFFS_BLOCK_STATE_EMPTY; |