int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
{
int blk;
int pg;
__u8 *x;
blk = chunkInNAND/PAGES_PER_BLOCK;
pg = chunkInNAND%PAGES_PER_BLOCK;
if(data)
{
memcpy(data,ned.block[blk]->page[pg]->data,PAGE_DATA_SIZE);
}
if(tags)
{
x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE];
yaffs_UnpackTags2(tags,(yaffs_PackedTags2 *)x);
}
return YAFFS_OK;
}
int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
__u8 * data, yaffs_ExtendedTags * tags)
{
struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
size_t dummy;
int retval = 0;
loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk;
yaffs_PackedTags2 pt;
T(YAFFS_TRACE_MTD,
(TSTR
("nandmtd2_ReadChunkWithTagsToNAND chunk %d data %p tags %p"
TENDSTR), chunkInNAND, data, tags));
if (0 && data && tags) {
retval =
mtd->read_ecc(mtd, addr, dev->nBytesPerChunk,
&dummy, data, dev->spareBuffer,
NULL);
nandmtd2_buf2pt(dev, &pt, 0);
} else {
if (data)
retval =
mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy,
data);
if (tags) {
retval =
mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
dev->spareBuffer);
nandmtd2_buf2pt(dev, &pt, 1);
}
}
if (tags)
yaffs_UnpackTags2(tags, &pt);
if (retval == 0)
return YAFFS_OK;
else
return YAFFS_FAIL;
}
int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
__u8 * data, yaffs_ExtendedTags * tags)
{
yaffs_PackedTags2 pt;
int localData = 0;
void *spare = NULL;
unsigned spareSize;
int eccStatus; //0 = ok, 1 = fixed, -1 = unfixed
unsigned char *bufferIn = DevBufferIn(dev);
unsigned char *bufferOut = DevBufferOut(dev);
unsigned bufferSize = DevBufferSize(dev);
T(YAFFS_TRACE_MTD,
(TSTR
("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
TENDSTR), chunkInNAND, data, tags));
if(!tags){
spare = NULL;
spareSize = 0;
}else if(dev->inbandTags){
if(!data) {
localData = 1;
data = yaffs_GetTempBuffer(dev,__LINE__);
}
spare = NULL;
spareSize = 0;
}
else {
spare = &pt;
spareSize = sizeof(yaffs_PackedTags2);
}
yramsim_ReadPage(chunkInNAND,
data,data ? dev->totalBytesPerChunk : 0,
spare,spareSize,
&eccStatus);
if(dev->inbandTags){
if(tags){
yaffs_PackedTags2TagsPart * pt2tp;
pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
yaffs_UnpackTags2TagsPart(tags,pt2tp);
}
}
else {
if (tags){
yaffs_UnpackTags2(tags, &pt);
}
}
if(tags && tags->chunkUsed){
if(eccStatus == 0)
tags->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
else if(eccStatus < 0)
tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
else
tags->eccResult = YAFFS_ECC_RESULT_FIXED;
}
if(localData)
yaffs_ReleaseTempBuffer(dev,data,__LINE__);
return YAFFS_OK;
}
int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
__u8 * data, yaffs_ExtendedTags * tags)
{
struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
struct mtd_oob_ops ops;
#endif
size_t dummy;
int retval = 0;
int localData = 0;
loff_t addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
yaffs_PackedTags2 pt;
T(YAFFS_TRACE_MTD,
(TSTR
("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
TENDSTR), chunkInNAND, data, tags));
if(dev->inbandTags){
if(!data) {
localData = 1;
data = yaffs_GetTempBuffer(dev,__LINE__);
}
}
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
if (dev->inbandTags || (data && !tags))
retval = mtd->read(mtd, addr, dev->totalBytesPerChunk,
&dummy, data);
else if (tags) {
ops.mode = MTD_OOB_AUTO;
ops.ooblen = sizeof(pt);
ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt);
ops.ooboffs = 0;
ops.datbuf = data;
ops.oobbuf = dev->spareBuffer;
retval = mtd->read_oob(mtd, addr, &ops);
}
#else
if (!dev->inbandTags && data && tags) {
retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
&dummy, data, dev->spareBuffer,
NULL);
} else {
if (data)
retval =
mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
data);
if (!dev->inbandTags && tags)
retval =
mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
dev->spareBuffer);
}
#endif
if(dev->inbandTags){
if(tags){
yaffs_PackedTags2TagsPart * pt2tp;
pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
yaffs_UnpackTags2TagsPart(tags,pt2tp);
}
}
else {
if (tags){
memcpy(&pt, dev->spareBuffer, sizeof(pt));
yaffs_UnpackTags2(tags, &pt);
}
}
if(localData)
yaffs_ReleaseTempBuffer(dev,data,__LINE__);
if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
if (retval == 0)
return YAFFS_OK;
else
return YAFFS_FAIL;
}
int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
__u8 * data, yaffs_ExtendedTags * tags)
{
struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
struct mtd_oob_ops ops;
#endif
size_t dummy;
int retval = 0;
loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
yaffs_PackedTags2 pt;
T(YAFFS_TRACE_MTD,
(TSTR
("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
TENDSTR), chunkInNAND, data, tags));
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
if (data && !tags)
retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
&dummy, data);
else if (tags) {
ops.mode = MTD_OOB_AUTO;
ops.ooblen = sizeof(pt);
ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt);
ops.ooboffs = 0;
ops.datbuf = data;
ops.oobbuf = dev->spareBuffer;
retval = mtd->read_oob(mtd, addr, &ops);
}
#else
if (data && tags) {
if (dev->useNANDECC) {
retval =
mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
&dummy, data, dev->spareBuffer,
NULL);
} else {
retval =
mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
&dummy, data, dev->spareBuffer,
NULL);
}
} else {
if (data)
retval =
mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
data);
if (tags)
retval =
mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
dev->spareBuffer);
}
#endif
/* The OOB data return from mtd->read_ecc and mtd->read_oob
are different, see nand driver, so need be different handled
*/
if(data && tags)
memcpy(&pt, dev->spareBuffer, sizeof(pt));
else
memcpy(&pt, dev->spareBuffer+YAFFS_INFO_START_POS, sizeof(pt));
if (tags)
yaffs_UnpackTags2(tags, &pt);
if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
if (retval == 0)
return YAFFS_OK;
else
return YAFFS_FAIL;
}
int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
{
int nread;
int pos;
int h;
CheckInit();
if(data)
{
pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
lseek(h,pos,SEEK_SET);
nread = read(h,data,dev->nDataBytesPerChunk);
if(nread != dev->nDataBytesPerChunk) return YAFFS_FAIL;
}
if(tags)
{
pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
lseek(h,pos,SEEK_SET);
if(0 && dev->isYaffs2)
{
nread= read(h,tags,sizeof(yaffs_ExtendedTags));
if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
{
yaffs_InitialiseTags(tags);
}
else
{
tags->chunkUsed = 1;
}
}
else
{
yaffs_PackedTags2 pt;
nread= read(h,&pt,sizeof(pt));
yaffs_UnpackTags2(tags,&pt);
if((chunkInNAND >> 6) == 300) {
if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
tags->eccResult = YAFFS_ECC_RESULT_FIXED;
fail300 = 0;
}
}
if((chunkInNAND >> 6) == 320) {
if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
tags->eccResult = YAFFS_ECC_RESULT_FIXED;
fail320 = 0;
}
}
if(nread != sizeof(pt)) return YAFFS_FAIL;
}
}
return YAFFS_OK;
}
int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
{
int nread;
int pos;
int h;
int localData = 0;
int retval = YAFFS_OK;
int nRead;
T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
CheckInit();
if(dev->inbandTags){
/* Got to suck the tags out of the data area */
if(!data) {
localData=1;
data = yaffs_GetTempBuffer(dev,__LINE__);
}
yaffs_PackedTags2TagsPart * pt2tp;
pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
lseek(h,pos,SEEK_SET);
nRead = read(h, data,dev->totalBytesPerChunk);
yaffs_UnpackTags2TagsPart(tags,pt2tp);
if(nread != dev->totalBytesPerChunk)
retval = YAFFS_FAIL;
if(localData)
yaffs_ReleaseTempBuffer(dev,data,__LINE__);
}
else {
if(data)
{
pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
lseek(h,pos,SEEK_SET);
nread = read(h,data,dev->nDataBytesPerChunk);
if(nread != dev->nDataBytesPerChunk)
retval = YAFFS_FAIL;
}
if(tags)
{
pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
lseek(h,pos,SEEK_SET);
if(0 && dev->isYaffs2)
{
nread= read(h,tags,sizeof(yaffs_ExtendedTags));
if(nread != sizeof(yaffs_ExtendedTags))
retval = YAFFS_FAIL;
if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
{
yaffs_InitialiseTags(tags);
}
else
{
tags->chunkUsed = 1;
}
}
else
{
yaffs_PackedTags2 pt;
nread= read(h,&pt,sizeof(pt));
yaffs_UnpackTags2(tags,&pt);
#ifdef SIMULATE_FAILURES
if((chunkInNAND >> 6) == 100) {
if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
tags->eccResult = YAFFS_ECC_RESULT_FIXED;
fail300 = 0;
}
}
if((chunkInNAND >> 6) == 110) {
if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
tags->eccResult = YAFFS_ECC_RESULT_FIXED;
fail320 = 0;
}
}
#endif
if(failRead10>0 && chunkInNAND == 10){
failRead10--;
nread = 0;
}
if(nread != sizeof(pt))
retval = YAFFS_FAIL;
}
}
}
return retval;
}
