qi-hardware/openwrt-xburst
1
0
Fork 0
mirror of git://projects.qi-hardware.com/openwrt-xburst.git synced 2025-04-21 12:27:27 +03:00
Code Activity

generic: fold yaffs_git_2010_10_20 patch to generic/files

Browse Source 
Signed-off-by: Gabor Juhos <juhosg@openwrt.org>

git-svn-id: svn://svn.openwrt.org/openwrt/trunk@34013 3c298f89-4303-0410-b956-a3cf2f4a3e73
This commit is contained in:
juhosg
2012-10-30 14:58:17 +00:00
parent 22c66493c9
commit 34b60fad1a
53 changed files with 11490 additions and 63077 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
target/linux/generic/files/fs/yaffs2/yaffs_nand.c
View File

@@ -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>
@@ -11,124 +11,129 @@
* published by the Free Software Foundation.
*/
const char *yaffs_nand_c_version =
"$Id: yaffs_nand.c,v 1.10 2009-03-06 17:20:54 wookey 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,
int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
__u8 *buffer,
yaffs_ExtendedTags *tags)
yaffs_ext_tags *tags)
{
int result;
yaffs_ExtendedTags localTags;
yaffs_ext_tags localTags;
int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
int realignedChunkInNAND = nand_chunk - dev->chunk_offset;
dev->n_page_reads++;
/* If there are no tags provided, use local tags to get prioritised gc working */
if (!tags)
tags = &localTags;
if (dev->readChunkWithTagsFromNAND)
result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer,
if (dev->param.read_chunk_tags_fn)
result = dev->param.read_chunk_tags_fn(dev, realignedChunkInNAND, buffer,
tags);
else
result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
result = yaffs_tags_compat_rd(dev,
realignedChunkInNAND,
buffer,
tags);
if (tags &&
tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) {
tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) {
yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
yaffs_HandleChunkError(dev, bi);
yaffs_block_info_t *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,
int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
int nand_chunk,
const __u8 *buffer,
yaffs_ExtendedTags *tags)
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)) {
tags->seq_number = dev->seq_number;
tags->chunk_used = 1;
if (!yaffs_validate_tags(tags)) {
T(YAFFS_TRACE_ERROR,
(TSTR("Writing uninitialised tags" TENDSTR)));
YBUG();
}
T(YAFFS_TRACE_WRITE,
(TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND,
tags->objectId, tags->chunkId));
(TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk,
tags->obj_id, tags->chunk_id));
} else {
T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR)));
YBUG();
}
if (dev->writeChunkWithTagsToNAND)
return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer,
if (dev->param.write_chunk_tags_fn)
return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer,
tags);
else
return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev,
chunkInNAND,
return yaffs_tags_compat_wr(dev,
nand_chunk,
buffer,
tags);
}
int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo)
int yaffs_mark_bad(yaffs_dev_t *dev, int block_no)
{
blockNo -= dev->blockOffset;
block_no -= dev->block_offset;
;
if (dev->markNANDBlockBad)
return dev->markNANDBlockBad(dev, blockNo);
if (dev->param.bad_block_fn)
return dev->param.bad_block_fn(dev, block_no);
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,
__u32 *sequenceNumber)
int yaffs_query_init_block_state(yaffs_dev_t *dev,
int block_no,
yaffs_block_state_t *state,
__u32 *seq_number)
{
blockNo -= dev->blockOffset;
block_no -= dev->block_offset;
if (dev->queryNANDBlock)
return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber);
if (dev->param.query_block_fn)
return dev->param.query_block_fn(dev, block_no, state, seq_number);
else
return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo,
return yaffs_tags_compat_query_block(dev, block_no,
state,
sequenceNumber);
seq_number);
}
int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
int blockInNAND)
int yaffs_erase_block(struct yaffs_dev_s *dev,
int flash_block)
{
int result;
blockInNAND -= dev->blockOffset;
flash_block -= dev->block_offset;
dev->n_erasures++;
dev->nBlockErasures++;
result = dev->eraseBlockInNAND(dev, blockInNAND);
result = dev->param.erase_fn(dev, flash_block);
return result;
}
int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
int yaffs_init_nand(struct yaffs_dev_s *dev)
{
return dev->initialiseNAND(dev);
if(dev->param.initialise_flash_fn)
return dev->param.initialise_flash_fn(dev);
return YAFFS_OK;
}