X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_nand.c;h=a1fe5c4bb1f657420aeddda609d96ff0e1e9be20;hp=989e8d91c43979220d1128949ed9f94e60e12393;hb=6500cebaa2c93512d544719956af259ca13f83b7;hpb=a8e9cfa2968a5f16ff9ae578cc1d3202ebef8725 diff --git a/yaffs_nand.c b/yaffs_nand.c index 989e8d9..a1fe5c4 100644 --- a/yaffs_nand.c +++ b/yaffs_nand.c @@ -1,7 +1,7 @@ /* - * YAFFS: Yet another FFS. A NAND-flash specific file system. + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002 Aleph One Ltd. + * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning @@ -9,125 +9,111 @@ * 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. - * */ - -const char *yaffs_nand_c_version = - "$Id: yaffs_nand.c,v 1.2 2006-09-21 08:13:59 charles Exp $"; #include "yaffs_nand.h" #include "yaffs_tagscompat.h" #include "yaffs_tagsvalidity.h" +#include "yaffs_getblockinfo.h" -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * buffer, - yaffs_ExtendedTags * tags) +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 *buffer, struct yaffs_ext_tags *tags) { int result; - - int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; + struct yaffs_ext_tags local_tags; + int realigned_chunk = nand_chunk - dev->chunk_offset; + + dev->n_page_reads++; - if (dev->readChunkWithTagsFromNAND) - result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, - tags); + /* If there are no tags provided use local tags. */ + if (!tags) + tags = &local_tags; + + if (dev->param.read_chunk_tags_fn) + result = + dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, + tags); else - result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev, - realignedChunkInNAND, - buffer, - tags); - if(tags && - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){ - - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock); - bi->gcPrioritise = 1; + result = yaffs_tags_compat_rd(dev, + realigned_chunk, buffer, tags); + if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { + + struct yaffs_block_info *bi; + bi = yaffs_get_block_info(dev, + nand_chunk / + dev->param.chunks_per_block); + yaffs_handle_chunk_error(dev, bi); } - return result; } -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev, - int chunkInNAND, - const __u8 * buffer, - yaffs_ExtendedTags * tags) +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 *buffer, struct yaffs_ext_tags *tags) { - chunkInNAND -= dev->chunkOffset; + dev->n_page_writes++; + nand_chunk -= dev->chunk_offset; - if (tags) { - tags->sequenceNumber = dev->sequenceNumber; - tags->chunkUsed = 1; - if (!yaffs_ValidateTags(tags)) { - T(YAFFS_TRACE_ERROR, - (TSTR("Writing uninitialised tags" TENDSTR))); - YBUG(); + tags->seq_number = dev->seq_number; + tags->chunk_used = 1; + if (!yaffs_validate_tags(tags)) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Writing uninitialised tags"); + BUG(); } - T(YAFFS_TRACE_WRITE, - (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND, - tags->objectId, tags->chunkId)); + yaffs_trace(YAFFS_TRACE_WRITE, + "Writing chunk %d tags %d %d", + nand_chunk, tags->obj_id, tags->chunk_id); } else { - T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR))); - YBUG(); + yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags"); + BUG(); + return YAFFS_FAIL; } - if (dev->writeChunkWithTagsToNAND) - return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, - tags); - else - return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev, - chunkInNAND, - buffer, - tags); + if (dev->param.write_chunk_tags_fn) + return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, + tags); + + return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags); } -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo) +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; + if (dev->param.bad_block_fn) + return dev->param.bad_block_fn(dev, block_no); -; - if (dev->markNANDBlockBad) - return dev->markNANDBlockBad(dev, blockNo); - else - return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo); + return yaffs_tags_compat_mark_bad(dev, block_no); } -int yaffs_QueryInitialBlockState(yaffs_Device * dev, - int blockNo, - yaffs_BlockState * state, - unsigned *sequenceNumber) +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 *seq_number) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; + if (dev->param.query_block_fn) + return dev->param.query_block_fn(dev, block_no, state, + seq_number); - if (dev->queryNANDBlock) - return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber); - else - return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo, - state, - sequenceNumber); + return yaffs_tags_compat_query_block(dev, block_no, state, seq_number); } - -int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block) { int result; - blockInNAND -= dev->blockOffset; - - - dev->nBlockErasures++; - result = dev->eraseBlockInNAND(dev, blockInNAND); - - /* If at first we don't succeed, try again *once*.*/ - if (!result) - result = dev->eraseBlockInNAND(dev, blockInNAND); + flash_block -= dev->block_offset; + dev->n_erasures++; + result = dev->param.erase_fn(dev, flash_block); return result; } -int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev) +int yaffs_init_nand(struct yaffs_dev *dev) { - return dev->initialiseNAND(dev); + if (dev->param.initialise_flash_fn) + return dev->param.initialise_flash_fn(dev); + return YAFFS_OK; } - - -